From b8075e4550a3ec9110930b41e09e77266482e54f Mon Sep 17 00:00:00 2001 From: Yuanheng Li <520dhh@gmail.com> Date: Sun, 21 Aug 2022 21:37:05 +0800 Subject: migrate rustc_query_system to use SessionDiagnostic with manual impl SessionDiagnostic --- compiler/rustc_query_system/src/error.rs | 60 ++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 compiler/rustc_query_system/src/error.rs (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs new file mode 100644 index 00000000000..2ae6d10b828 --- /dev/null +++ b/compiler/rustc_query_system/src/error.rs @@ -0,0 +1,60 @@ +use rustc_errors::{DiagnosticBuilder, ErrorGuaranteed}; +use rustc_session::SessionDiagnostic; +use rustc_span::Span; + +pub struct Cycle { + pub span: Span, + pub stack_bottom: String, + pub upper_stack_info: Vec<(Span, String)>, + pub recursive_ty_alias: bool, + pub recursive_trait_alias: bool, + pub cycle_usage: Option<(Span, String)>, +} + +impl SessionDiagnostic<'_> for Cycle { + fn into_diagnostic( + self, + sess: &'_ rustc_session::parse::ParseSess, + ) -> DiagnosticBuilder<'_, ErrorGuaranteed> { + let mut diag = sess.struct_err(rustc_errors::fluent::query_system::cycle); + diag.set_span(self.span); + diag.code(rustc_errors::DiagnosticId::Error("E0391".to_string())); + let upper_stack_len = self.upper_stack_info.len(); + for (span, desc) in self.upper_stack_info.into_iter() { + // FIXME: use fluent translation + diag.span_note(span, &format!("...which requires {}...", desc)); + } + diag.set_arg("stack_bottom", self.stack_bottom); + if upper_stack_len == 0 { + diag.note(rustc_errors::fluent::query_system::cycle_stack_single); + } else { + diag.note(rustc_errors::fluent::query_system::cycle_stack_multiple); + } + if self.recursive_trait_alias { + diag.note(rustc_errors::fluent::query_system::cycle_recursive_trait_alias); + } else if self.recursive_ty_alias { + diag.note(rustc_errors::fluent::query_system::cycle_recursive_ty_alias); + diag.help(rustc_errors::fluent::query_system::cycle_recursive_ty_alias_help1); + diag.help(rustc_errors::fluent::query_system::cycle_recursive_ty_alias_help2); + } + if let Some((span, desc)) = self.cycle_usage { + diag.set_arg("usage", desc); + diag.span_note(span, rustc_errors::fluent::query_system::cycle_usage); + } + diag + } +} + +#[derive(SessionDiagnostic)] +#[diag(query_system::reentrant)] +pub struct Reentrant; + +#[derive(SessionDiagnostic)] +#[diag(query_system::increment_compilation)] +#[help] +#[note(query_system::increment_compilation_note1)] +#[note(query_system::increment_compilation_note2)] +pub struct IncrementCompilation { + pub run_cmd: String, + pub dep_node: String, +} -- cgit 1.4.1-3-g733a5 From d7e07c0b6b08e898a0720bf9c2fd2a22404bdfec Mon Sep 17 00:00:00 2001 From: Li Yuanheng <520dhh@gmail.com> Date: Tue, 23 Aug 2022 07:23:36 +0800 Subject: link related issue to FIXME Co-authored-by: David Wood --- compiler/rustc_query_system/src/error.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs index 2ae6d10b828..515a022e9d9 100644 --- a/compiler/rustc_query_system/src/error.rs +++ b/compiler/rustc_query_system/src/error.rs @@ -21,7 +21,7 @@ impl SessionDiagnostic<'_> for Cycle { diag.code(rustc_errors::DiagnosticId::Error("E0391".to_string())); let upper_stack_len = self.upper_stack_info.len(); for (span, desc) in self.upper_stack_info.into_iter() { - // FIXME: use fluent translation + // FIXME(#100717): use fluent translation diag.span_note(span, &format!("...which requires {}...", desc)); } diag.set_arg("stack_bottom", self.stack_bottom); -- cgit 1.4.1-3-g733a5 From ac638c1f5fca36484506415319ab254ad522a692 Mon Sep 17 00:00:00 2001 From: Yuanheng Li <520dhh@gmail.com> Date: Tue, 23 Aug 2022 11:19:38 +0800 Subject: use derive proc macro to impl SessionDiagnostic fixes `SessionSubdiagnostic` to accept multiple attributes emitting list of fluent message remains unresolved --- .../locales/en-US/query_system.ftl | 2 + .../rustc_macros/src/diagnostics/subdiagnostic.rs | 694 ++++++++------------- compiler/rustc_query_system/src/error.rs | 87 +-- compiler/rustc_query_system/src/lib.rs | 2 +- compiler/rustc_query_system/src/query/job.rs | 43 +- .../session-diagnostic/subdiagnostic-derive.rs | 164 +---- .../session-diagnostic/subdiagnostic-derive.stderr | 234 ++----- 7 files changed, 415 insertions(+), 811 deletions(-) (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_error_messages/locales/en-US/query_system.ftl b/compiler/rustc_error_messages/locales/en-US/query_system.ftl index 2d8c7a65122..7fdecf4f381 100644 --- a/compiler/rustc_error_messages/locales/en-US/query_system.ftl +++ b/compiler/rustc_error_messages/locales/en-US/query_system.ftl @@ -19,3 +19,5 @@ query_system_cycle_recursive_ty_alias_help1 = consider using a struct, enum, or query_system_cycle_recursive_ty_alias_help2 = see for more information query_system_cycle_recursive_trait_alias = trait aliases cannot be recursive + +query_system_cycle_which_requires = ...which requires {$desc}... diff --git a/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs b/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs index 8b40e295bd8..c1b82abc1e0 100644 --- a/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs +++ b/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs @@ -12,7 +12,7 @@ use quote::{format_ident, quote}; use std::collections::HashMap; use std::fmt; use std::str::FromStr; -use syn::{spanned::Spanned, Attribute, Meta, MetaList, MetaNameValue, NestedMeta, Path}; +use syn::{spanned::Spanned, Meta, MetaList, MetaNameValue, NestedMeta, Path}; use synstructure::{BindingInfo, Structure, VariantInfo}; /// Which kind of suggestion is being created? @@ -28,41 +28,8 @@ enum SubdiagnosticSuggestionKind { Verbose, } -impl FromStr for SubdiagnosticSuggestionKind { - type Err = (); - - fn from_str(s: &str) -> Result { - match s { - "" => Ok(SubdiagnosticSuggestionKind::Normal), - "_short" => Ok(SubdiagnosticSuggestionKind::Short), - "_hidden" => Ok(SubdiagnosticSuggestionKind::Hidden), - "_verbose" => Ok(SubdiagnosticSuggestionKind::Verbose), - _ => Err(()), - } - } -} - -impl SubdiagnosticSuggestionKind { - pub fn to_suggestion_style(&self) -> TokenStream { - match self { - SubdiagnosticSuggestionKind::Normal => { - quote! { rustc_errors::SuggestionStyle::ShowCode } - } - SubdiagnosticSuggestionKind::Short => { - quote! { rustc_errors::SuggestionStyle::HideCodeInline } - } - SubdiagnosticSuggestionKind::Hidden => { - quote! { rustc_errors::SuggestionStyle::HideCodeAlways } - } - SubdiagnosticSuggestionKind::Verbose => { - quote! { rustc_errors::SuggestionStyle::ShowAlways } - } - } - } -} - /// Which kind of subdiagnostic is being created from a variant? -#[derive(Clone)] +#[derive(Clone, Copy)] enum SubdiagnosticKind { /// `#[label(...)]` Label, @@ -73,9 +40,31 @@ enum SubdiagnosticKind { /// `#[warning(...)]` Warn, /// `#[suggestion{,_short,_hidden,_verbose}]` - Suggestion { suggestion_kind: SubdiagnosticSuggestionKind, code: TokenStream }, - /// `#[multipart_suggestion{,_short,_hidden,_verbose}]` - MultipartSuggestion { suggestion_kind: SubdiagnosticSuggestionKind }, + Suggestion(SubdiagnosticSuggestionKind), +} + +impl FromStr for SubdiagnosticKind { + type Err = (); + + fn from_str(s: &str) -> Result { + match s { + "label" => Ok(SubdiagnosticKind::Label), + "note" => Ok(SubdiagnosticKind::Note), + "help" => Ok(SubdiagnosticKind::Help), + "warning" => Ok(SubdiagnosticKind::Warn), + "suggestion" => Ok(SubdiagnosticKind::Suggestion(SubdiagnosticSuggestionKind::Normal)), + "suggestion_short" => { + Ok(SubdiagnosticKind::Suggestion(SubdiagnosticSuggestionKind::Short)) + } + "suggestion_hidden" => { + Ok(SubdiagnosticKind::Suggestion(SubdiagnosticSuggestionKind::Hidden)) + } + "suggestion_verbose" => { + Ok(SubdiagnosticKind::Suggestion(SubdiagnosticSuggestionKind::Verbose)) + } + _ => Err(()), + } + } } impl quote::IdentFragment for SubdiagnosticKind { @@ -85,9 +74,17 @@ impl quote::IdentFragment for SubdiagnosticKind { SubdiagnosticKind::Note => write!(f, "note"), SubdiagnosticKind::Help => write!(f, "help"), SubdiagnosticKind::Warn => write!(f, "warn"), - SubdiagnosticKind::Suggestion { .. } => write!(f, "suggestion_with_style"), - SubdiagnosticKind::MultipartSuggestion { .. } => { - write!(f, "multipart_suggestion_with_style") + SubdiagnosticKind::Suggestion(SubdiagnosticSuggestionKind::Normal) => { + write!(f, "suggestion") + } + SubdiagnosticKind::Suggestion(SubdiagnosticSuggestionKind::Short) => { + write!(f, "suggestion_short") + } + SubdiagnosticKind::Suggestion(SubdiagnosticSuggestionKind::Hidden) => { + write!(f, "suggestion_hidden") + } + SubdiagnosticKind::Suggestion(SubdiagnosticSuggestionKind::Verbose) => { + write!(f, "suggestion_verbose") } } } @@ -151,9 +148,11 @@ impl<'a> SessionSubdiagnosticDerive<'a> { variant, span, fields: fields_map, + kinds: Vec::new(), + slugs: Vec::new(), + code: None, span_field: None, applicability: None, - has_suggestion_parts: false, }; builder.into_tokens().unwrap_or_else(|v| v.to_compile_error()) }); @@ -194,15 +193,21 @@ struct SessionSubdiagnosticDeriveBuilder<'a> { /// derive builder. fields: HashMap, + /// Subdiagnostic kind of the type/variant. + kinds: Vec<(SubdiagnosticKind, proc_macro::Span)>, + + /// Slugs of the subdiagnostic - corresponds to the Fluent identifier for the message - from the + /// `#[kind(slug)]` attribute on the type or variant. + slugs: Vec<(Path, proc_macro::Span)>, + /// If a suggestion, the code to suggest as a replacement - from the `#[kind(code = "...")]` + /// attribute on the type or variant. + code: Option<(TokenStream, proc_macro::Span)>, + /// Identifier for the binding to the `#[primary_span]` field. span_field: Option<(proc_macro2::Ident, proc_macro::Span)>, /// If a suggestion, the identifier for the binding to the `#[applicability]` field or a /// `rustc_errors::Applicability::*` variant directly. applicability: Option<(TokenStream, proc_macro::Span)>, - - /// Set to true when a `#[suggestion_part]` field is encountered, used to generate an error - /// during finalization if still `false`. - has_suggestion_parts: bool, } impl<'a> HasFieldMap for SessionSubdiagnosticDeriveBuilder<'a> { @@ -212,133 +217,124 @@ impl<'a> HasFieldMap for SessionSubdiagnosticDeriveBuilder<'a> { } impl<'a> SessionSubdiagnosticDeriveBuilder<'a> { - fn identify_kind( - &mut self, - ) -> Result, DiagnosticDeriveError> { - let mut kind_slug = None; - - for attr in self.variant.ast().attrs { + fn identify_kind(&mut self) -> Result<(), DiagnosticDeriveError> { + for (i, attr) in self.variant.ast().attrs.iter().enumerate() { let span = attr.span().unwrap(); let name = attr.path.segments.last().unwrap().ident.to_string(); let name = name.as_str(); let meta = attr.parse_meta()?; - let Meta::List(MetaList { ref nested, .. }) = meta else { - throw_invalid_attr!(attr, &meta); - }; - - let mut kind = match name { - "label" => SubdiagnosticKind::Label, - "note" => SubdiagnosticKind::Note, - "help" => SubdiagnosticKind::Help, - "warning" => SubdiagnosticKind::Warn, - _ => { - if let Some(suggestion_kind) = - name.strip_prefix("suggestion").and_then(|s| s.parse().ok()) - { - SubdiagnosticKind::Suggestion { suggestion_kind, code: TokenStream::new() } - } else if let Some(suggestion_kind) = - name.strip_prefix("multipart_suggestion").and_then(|s| s.parse().ok()) - { - SubdiagnosticKind::MultipartSuggestion { suggestion_kind } - } else { - throw_invalid_attr!(attr, &meta); + let kind = match meta { + Meta::List(MetaList { ref nested, .. }) => { + let mut nested_iter = nested.into_iter(); + if let Some(nested_attr) = nested_iter.next() { + match nested_attr { + NestedMeta::Meta(Meta::Path(path)) => { + self.slugs.push((path.clone(), span)); + } + NestedMeta::Meta(meta @ Meta::NameValue(_)) + if matches!( + meta.path().segments.last().unwrap().ident.to_string().as_str(), + "code" | "applicability" + ) => + { + // don't error for valid follow-up attributes + } + nested_attr => { + throw_invalid_nested_attr!(attr, &nested_attr, |diag| { + diag.help( + "first argument of the attribute should be the diagnostic \ + slug", + ) + }) + } + }; } - } - }; - let mut slug = None; - let mut code = None; - - let mut nested_iter = nested.into_iter(); - if let Some(nested_attr) = nested_iter.next() { - match nested_attr { - NestedMeta::Meta(Meta::Path(path)) => { - slug.set_once((path.clone(), span)); - } - NestedMeta::Meta(meta @ Meta::NameValue(_)) - if matches!( - meta.path().segments.last().unwrap().ident.to_string().as_str(), - "code" | "applicability" - ) => - { - // Don't error for valid follow-up attributes. - } - nested_attr => { - throw_invalid_nested_attr!(attr, &nested_attr, |diag| { - diag.help( - "first argument of the attribute should be the diagnostic \ - slug", - ) - }) + for nested_attr in nested_iter { + let meta = match nested_attr { + NestedMeta::Meta(ref meta) => meta, + _ => throw_invalid_nested_attr!(attr, &nested_attr), + }; + + let span = meta.span().unwrap(); + let nested_name = meta.path().segments.last().unwrap().ident.to_string(); + let nested_name = nested_name.as_str(); + + match meta { + Meta::NameValue(MetaNameValue { lit: syn::Lit::Str(s), .. }) => { + match nested_name { + "code" => { + let formatted_str = self.build_format(&s.value(), s.span()); + self.code.set_once((formatted_str, span)); + } + "applicability" => { + let value = match Applicability::from_str(&s.value()) { + Ok(v) => v, + Err(()) => { + span_err(span, "invalid applicability").emit(); + Applicability::Unspecified + } + }; + self.applicability.set_once((quote! { #value }, span)); + } + _ => throw_invalid_nested_attr!(attr, &nested_attr, |diag| { + diag.help( + "only `code` and `applicability` are valid nested \ + attributes", + ) + }), + } + } + _ => throw_invalid_nested_attr!(attr, &nested_attr, |diag| { + if matches!(meta, Meta::Path(_)) { + diag.help( + "a diagnostic slug must be the first argument to the \ + attribute", + ) + } else { + diag + } + }), + } } - }; - } - for nested_attr in nested_iter { - let meta = match nested_attr { - NestedMeta::Meta(ref meta) => meta, - _ => throw_invalid_nested_attr!(attr, &nested_attr), - }; + let Ok(kind) = SubdiagnosticKind::from_str(name) else { + throw_invalid_attr!(attr, &meta) + }; - let span = meta.span().unwrap(); - let nested_name = meta.path().segments.last().unwrap().ident.to_string(); - let nested_name = nested_name.as_str(); + kind + } + _ => throw_invalid_attr!(attr, &meta), + }; - let value = match meta { - Meta::NameValue(MetaNameValue { lit: syn::Lit::Str(value), .. }) => value, - Meta::Path(_) => throw_invalid_nested_attr!(attr, &nested_attr, |diag| { - diag.help("a diagnostic slug must be the first argument to the attribute") - }), - _ => throw_invalid_nested_attr!(attr, &nested_attr), - }; + if matches!( + kind, + SubdiagnosticKind::Label | SubdiagnosticKind::Help | SubdiagnosticKind::Note + ) && self.code.is_some() + { + throw_span_err!( + span, + &format!("`code` is not a valid nested attribute of a `{}` attribute", name) + ); + } - match nested_name { - "code" => { - if matches!(kind, SubdiagnosticKind::Suggestion { .. }) { - let formatted_str = self.build_format(&value.value(), value.span()); - code.set_once((formatted_str, span)); - } else { - span_err( - span, - &format!( - "`code` is not a valid nested attribute of a `{}` attribute", - name - ), - ) - .emit(); - } - } - "applicability" => { - if matches!( - kind, - SubdiagnosticKind::Suggestion { .. } - | SubdiagnosticKind::MultipartSuggestion { .. } - ) { - let value = - Applicability::from_str(&value.value()).unwrap_or_else(|()| { - span_err(span, "invalid applicability").emit(); - Applicability::Unspecified - }); - self.applicability.set_once((quote! { #value }, span)); - } else { - span_err( - span, - &format!( - "`applicability` is not a valid nested attribute of a `{}` attribute", - name - ) - ).emit(); - } - } - _ => throw_invalid_nested_attr!(attr, &nested_attr, |diag| { - diag.help("only `code` and `applicability` are valid nested attributes") - }), - } + if matches!( + kind, + SubdiagnosticKind::Label | SubdiagnosticKind::Help | SubdiagnosticKind::Note + ) && self.applicability.is_some() + { + throw_span_err!( + span, + &format!( + "`applicability` is not a valid nested attribute of a `{}` attribute", + name + ) + ); } - let Some((slug, _)) = slug else { + if self.slugs.len() != i + 1 { throw_span_err!( span, &format!( @@ -346,338 +342,146 @@ impl<'a> SessionSubdiagnosticDeriveBuilder<'a> { name ) ); - }; - - match kind { - SubdiagnosticKind::Suggestion { code: ref mut code_field, .. } => { - let Some((code, _)) = code else { - throw_span_err!(span, "suggestion without `code = \"...\"`"); - }; - *code_field = code; - } - SubdiagnosticKind::Label - | SubdiagnosticKind::Note - | SubdiagnosticKind::Help - | SubdiagnosticKind::Warn - | SubdiagnosticKind::MultipartSuggestion { .. } => {} } - kind_slug.set_once(((kind, slug), span)) + self.kinds.push((kind, span)); } - Ok(kind_slug.map(|(kind_slug, _)| kind_slug)) - } - - /// Generates the code for a field with no attributes. - fn generate_field_set_arg(&mut self, binding: &BindingInfo<'_>) -> TokenStream { - let ast = binding.ast(); - assert_eq!(ast.attrs.len(), 0, "field with attribute used as diagnostic arg"); - - let diag = &self.diag; - let ident = ast.ident.as_ref().unwrap(); - quote! { - #diag.set_arg( - stringify!(#ident), - #binding - ); - } + Ok(()) } - /// Generates the necessary code for all attributes on a field. - fn generate_field_attr_code( + fn generate_field_code( &mut self, binding: &BindingInfo<'_>, - kind: &SubdiagnosticKind, - ) -> TokenStream { + have_suggestion: bool, + ) -> Result { let ast = binding.ast(); - assert!(ast.attrs.len() > 0, "field without attributes generating attr code"); - // Abstract over `Vec` and `Option` fields using `FieldInnerTy`, which will - // apply the generated code on each element in the `Vec` or `Option`. let inner_ty = FieldInnerTy::from_type(&ast.ty); - ast.attrs - .iter() - .map(|attr| { - let info = FieldInfo { - binding, - ty: inner_ty.inner_type().unwrap_or(&ast.ty), - span: &ast.span(), - }; - - let generated = self - .generate_field_code_inner(kind, attr, info) - .unwrap_or_else(|v| v.to_compile_error()); - - inner_ty.with(binding, generated) - }) - .collect() - } - - fn generate_field_code_inner( - &mut self, - kind: &SubdiagnosticKind, - attr: &Attribute, - info: FieldInfo<'_>, - ) -> Result { - let meta = attr.parse_meta()?; - match meta { - Meta::Path(path) => self.generate_field_code_inner_path(kind, attr, info, path), - Meta::List(list @ MetaList { .. }) => { - self.generate_field_code_inner_list(kind, attr, info, list) - } - _ => throw_invalid_attr!(attr, &meta), - } - } - - /// Generates the code for a `[Meta::Path]`-like attribute on a field (e.g. `#[primary_span]`). - fn generate_field_code_inner_path( - &mut self, - kind: &SubdiagnosticKind, - attr: &Attribute, - info: FieldInfo<'_>, - path: Path, - ) -> Result { - let span = attr.span().unwrap(); - let ident = &path.segments.last().unwrap().ident; - let name = ident.to_string(); - let name = name.as_str(); - - match name { - "skip_arg" => Ok(quote! {}), - "primary_span" => { - if matches!(kind, SubdiagnosticKind::MultipartSuggestion { .. }) { - throw_invalid_attr!(attr, &Meta::Path(path), |diag| { - diag.help( - "multipart suggestions use one or more `#[suggestion_part]`s rather \ - than one `#[primary_span]`", - ) - }) - } - - report_error_if_not_applied_to_span(attr, &info)?; + let info = FieldInfo { + binding: binding, + ty: inner_ty.inner_type().unwrap_or(&ast.ty), + span: &ast.span(), + }; - let binding = info.binding.binding.clone(); - self.span_field.set_once((binding, span)); + for attr in &ast.attrs { + let name = attr.path.segments.last().unwrap().ident.to_string(); + let name = name.as_str(); + let span = attr.span().unwrap(); - Ok(quote! {}) - } - "suggestion_part" => { - self.has_suggestion_parts = true; - - match kind { - SubdiagnosticKind::MultipartSuggestion { .. } => { - span_err( - span, - "`#[suggestion_part(...)]` attribute without `code = \"...\"`", - ) - .emit(); - Ok(quote! {}) + let meta = attr.parse_meta()?; + match meta { + Meta::Path(_) => match name { + "primary_span" => { + report_error_if_not_applied_to_span(attr, &info)?; + self.span_field.set_once((binding.binding.clone(), span)); + return Ok(quote! {}); } - SubdiagnosticKind::Label - | SubdiagnosticKind::Note - | SubdiagnosticKind::Help - | SubdiagnosticKind::Warn - | SubdiagnosticKind::Suggestion { .. } => { - throw_invalid_attr!(attr, &Meta::Path(path), |diag| { - diag.help( - "`#[suggestion_part(...)]` is only valid in multipart suggestions, use `#[primary_span]` instead", - ) - }); + "applicability" if have_suggestion => { + report_error_if_not_applied_to_applicability(attr, &info)?; + let binding = binding.binding.clone(); + self.applicability.set_once((quote! { #binding }, span)); + return Ok(quote! {}); } - } - } - "applicability" => { - if let SubdiagnosticKind::Suggestion { .. } - | SubdiagnosticKind::MultipartSuggestion { .. } = kind - { - report_error_if_not_applied_to_applicability(attr, &info)?; - - let binding = info.binding.binding.clone(); - self.applicability.set_once((quote! { #binding }, span)); - } else { - span_err(span, "`#[applicability]` is only valid on suggestions").emit(); - } - - Ok(quote! {}) - } - _ => throw_invalid_attr!(attr, &Meta::Path(path), |diag| { - let span_attr = if let SubdiagnosticKind::MultipartSuggestion { .. } = kind { - "suggestion_part" - } else { - "primary_span" - }; - diag.help(format!( - "only `{span_attr}`, `applicability` and `skip_arg` are valid field attributes", - )) - }), - } - } - - /// Generates the code for a `[Meta::List]`-like attribute on a field (e.g. - /// `#[suggestion_part(code = "...")]`). - fn generate_field_code_inner_list( - &mut self, - kind: &SubdiagnosticKind, - attr: &Attribute, - info: FieldInfo<'_>, - list: MetaList, - ) -> Result { - let span = attr.span().unwrap(); - let ident = &list.path.segments.last().unwrap().ident; - let name = ident.to_string(); - let name = name.as_str(); - - match name { - "suggestion_part" => { - if !matches!(kind, SubdiagnosticKind::MultipartSuggestion { .. }) { - throw_invalid_attr!(attr, &Meta::List(list), |diag| { + "applicability" => { + span_err(span, "`#[applicability]` is only valid on suggestions").emit(); + return Ok(quote! {}); + } + "skip_arg" => { + return Ok(quote! {}); + } + _ => throw_invalid_attr!(attr, &meta, |diag| { diag.help( - "`#[suggestion_part(...)]` is only valid in multipart suggestions", + "only `primary_span`, `applicability` and `skip_arg` are valid field \ + attributes", ) - }) - } - - self.has_suggestion_parts = true; - - report_error_if_not_applied_to_span(attr, &info)?; - - let mut code = None; - for nested_attr in list.nested.iter() { - let NestedMeta::Meta(ref meta) = nested_attr else { - throw_invalid_nested_attr!(attr, &nested_attr); - }; - - let span = meta.span().unwrap(); - let nested_name = meta.path().segments.last().unwrap().ident.to_string(); - let nested_name = nested_name.as_str(); - - let Meta::NameValue(MetaNameValue { lit: syn::Lit::Str(value), .. }) = meta else { - throw_invalid_nested_attr!(attr, &nested_attr); - }; + }), + }, + _ => throw_invalid_attr!(attr, &meta), + } + } - match nested_name { - "code" => { - let formatted_str = self.build_format(&value.value(), value.span()); - code.set_once((formatted_str, span)); - } - _ => throw_invalid_nested_attr!(attr, &nested_attr, |diag| { - diag.help("`code` is the only valid nested attribute") - }), - } - } + let ident = ast.ident.as_ref().unwrap(); - let Some((code, _)) = code else { - span_err(span, "`#[suggestion_part(...)]` attribute without `code = \"...\"`") - .emit(); - return Ok(quote! {}); - }; - let binding = info.binding; + let diag = &self.diag; + let generated = quote! { + #diag.set_arg( + stringify!(#ident), + #binding + ); + }; - Ok(quote! { suggestions.push((#binding, #code)); }) - } - _ => throw_invalid_attr!(attr, &Meta::List(list), |diag| { - let span_attr = if let SubdiagnosticKind::MultipartSuggestion { .. } = kind { - "suggestion_part" - } else { - "primary_span" - }; - diag.help(format!( - "only `{span_attr}`, `applicability` and `skip_arg` are valid field attributes", - )) - }), - } + Ok(inner_ty.with(binding, generated)) } - pub fn into_tokens(&mut self) -> Result { - let Some((kind, slug)) = self.identify_kind()? else { + fn into_tokens(&mut self) -> Result { + self.identify_kind()?; + if self.kinds.is_empty() { throw_span_err!( self.variant.ast().ident.span().unwrap(), "subdiagnostic kind not specified" ); }; + let have_suggestion = + self.kinds.iter().any(|(k, _)| matches!(k, SubdiagnosticKind::Suggestion(_))); + let mut args = TokenStream::new(); + for binding in self.variant.bindings() { + let arg = self + .generate_field_code(binding, have_suggestion) + .unwrap_or_else(|v| v.to_compile_error()); + args.extend(arg); + } + let mut tokens = TokenStream::new(); + for ((kind, _), (slug, _)) in self.kinds.iter().zip(&self.slugs) { + let code = match self.code.as_ref() { + Some((code, _)) => Some(quote! { #code }), + None if have_suggestion => { + span_err(self.span, "suggestion without `code = \"...\"`").emit(); + Some(quote! { /* macro error */ "..." }) + } + None => None, + }; - let init = match &kind { - SubdiagnosticKind::Label - | SubdiagnosticKind::Note - | SubdiagnosticKind::Help - | SubdiagnosticKind::Warn - | SubdiagnosticKind::Suggestion { .. } => quote! {}, - SubdiagnosticKind::MultipartSuggestion { .. } => { - quote! { let mut suggestions = Vec::new(); } - } - }; - - let attr_args: TokenStream = self - .variant - .bindings() - .iter() - .filter(|binding| !binding.ast().attrs.is_empty()) - .map(|binding| self.generate_field_attr_code(binding, &kind)) - .collect(); - - let span_field = self.span_field.as_ref().map(|(span, _)| span); - let applicability = self.applicability.take().map_or_else( - || quote! { rustc_errors::Applicability::Unspecified }, - |(applicability, _)| applicability, - ); + let span_field = self.span_field.as_ref().map(|(span, _)| span); + let applicability = match self.applicability.clone() { + Some((applicability, _)) => Some(applicability), + None if have_suggestion => { + span_err(self.span, "suggestion without `applicability`").emit(); + Some(quote! { rustc_errors::Applicability::Unspecified }) + } + None => None, + }; - let diag = &self.diag; - let name = format_ident!("{}{}", if span_field.is_some() { "span_" } else { "" }, kind); - let message = quote! { rustc_errors::fluent::#slug }; - let call = match kind { - SubdiagnosticKind::Suggestion { suggestion_kind, code } => { + let diag = &self.diag; + let name = format_ident!("{}{}", if span_field.is_some() { "span_" } else { "" }, kind); + let message = quote! { rustc_errors::fluent::#slug }; + let call = if matches!(kind, SubdiagnosticKind::Suggestion(..)) { if let Some(span) = span_field { - let style = suggestion_kind.to_suggestion_style(); - - quote! { #diag.#name(#span, #message, #code, #applicability, #style); } + quote! { #diag.#name(#span, #message, #code, #applicability); } } else { span_err(self.span, "suggestion without `#[primary_span]` field").emit(); quote! { unreachable!(); } } - } - SubdiagnosticKind::MultipartSuggestion { suggestion_kind } => { - if !self.has_suggestion_parts { - span_err( - self.span, - "multipart suggestion without any `#[suggestion_part(...)]` fields", - ) - .emit(); - } - - let style = suggestion_kind.to_suggestion_style(); - - quote! { #diag.#name(#message, suggestions, #applicability, #style); } - } - SubdiagnosticKind::Label => { + } else if matches!(kind, SubdiagnosticKind::Label) { if let Some(span) = span_field { quote! { #diag.#name(#span, #message); } } else { span_err(self.span, "label without `#[primary_span]` field").emit(); quote! { unreachable!(); } } - } - _ => { + } else { if let Some(span) = span_field { quote! { #diag.#name(#span, #message); } } else { quote! { #diag.#name(#message); } } - } - }; + }; + tokens.extend(quote! { + #call + #args + }); + } - let plain_args: TokenStream = self - .variant - .bindings() - .iter() - .filter(|binding| binding.ast().attrs.is_empty()) - .map(|binding| self.generate_field_set_arg(binding)) - .collect(); - - Ok(quote! { - #init - #attr_args - #call - #plain_args - }) + Ok(tokens) } } diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs index 515a022e9d9..9b808afeef6 100644 --- a/compiler/rustc_query_system/src/error.rs +++ b/compiler/rustc_query_system/src/error.rs @@ -1,50 +1,59 @@ -use rustc_errors::{DiagnosticBuilder, ErrorGuaranteed}; -use rustc_session::SessionDiagnostic; +use rustc_errors::AddSubdiagnostic; use rustc_span::Span; -pub struct Cycle { +pub struct CycleStack { pub span: Span, - pub stack_bottom: String, - pub upper_stack_info: Vec<(Span, String)>, - pub recursive_ty_alias: bool, - pub recursive_trait_alias: bool, - pub cycle_usage: Option<(Span, String)>, + pub desc: String, } -impl SessionDiagnostic<'_> for Cycle { - fn into_diagnostic( - self, - sess: &'_ rustc_session::parse::ParseSess, - ) -> DiagnosticBuilder<'_, ErrorGuaranteed> { - let mut diag = sess.struct_err(rustc_errors::fluent::query_system::cycle); - diag.set_span(self.span); - diag.code(rustc_errors::DiagnosticId::Error("E0391".to_string())); - let upper_stack_len = self.upper_stack_info.len(); - for (span, desc) in self.upper_stack_info.into_iter() { - // FIXME(#100717): use fluent translation - diag.span_note(span, &format!("...which requires {}...", desc)); - } - diag.set_arg("stack_bottom", self.stack_bottom); - if upper_stack_len == 0 { - diag.note(rustc_errors::fluent::query_system::cycle_stack_single); - } else { - diag.note(rustc_errors::fluent::query_system::cycle_stack_multiple); - } - if self.recursive_trait_alias { - diag.note(rustc_errors::fluent::query_system::cycle_recursive_trait_alias); - } else if self.recursive_ty_alias { - diag.note(rustc_errors::fluent::query_system::cycle_recursive_ty_alias); - diag.help(rustc_errors::fluent::query_system::cycle_recursive_ty_alias_help1); - diag.help(rustc_errors::fluent::query_system::cycle_recursive_ty_alias_help2); - } - if let Some((span, desc)) = self.cycle_usage { - diag.set_arg("usage", desc); - diag.span_note(span, rustc_errors::fluent::query_system::cycle_usage); - } - diag +impl AddSubdiagnostic for CycleStack { + fn add_to_diagnostic(self, diag: &mut rustc_errors::Diagnostic) { + diag.span_note(self.span, &format!("...which requires {}...", self.desc)); } } +#[derive(SessionSubdiagnostic)] +pub enum StackCount { + #[note(query_system::cycle_stack_single)] + Single, + #[note(query_system::cycle_stack_multiple)] + Multiple, +} + +#[derive(SessionSubdiagnostic)] +pub enum Alias { + #[note(query_system::cycle_recursive_ty_alias)] + #[help(query_system::cycle_recursive_ty_alias_help1)] + #[help(query_system::cycle_recursive_ty_alias_help2)] + Ty, + #[note(query_system::cycle_recursive_trait_alias)] + Trait, +} + +#[derive(SessionSubdiagnostic)] +#[note(query_system::cycle_usage)] +pub struct CycleUsage { + #[primary_span] + pub span: Span, + pub usage: String, +} + +#[derive(SessionDiagnostic)] +#[diag(query_system::cycle, code = "E0391")] +pub struct Cycle { + #[primary_span] + pub span: Span, + pub stack_bottom: String, + #[subdiagnostic] + pub cycle_stack: Vec, + #[subdiagnostic] + pub stack_count: StackCount, + #[subdiagnostic] + pub alias: Option, + #[subdiagnostic] + pub cycle_usage: Option, +} + #[derive(SessionDiagnostic)] #[diag(query_system::reentrant)] pub struct Reentrant; diff --git a/compiler/rustc_query_system/src/lib.rs b/compiler/rustc_query_system/src/lib.rs index da775893a2b..7067bc5f09c 100644 --- a/compiler/rustc_query_system/src/lib.rs +++ b/compiler/rustc_query_system/src/lib.rs @@ -5,7 +5,7 @@ #![feature(min_specialization)] #![feature(extern_types)] #![allow(rustc::potential_query_instability)] -#![deny(rustc::untranslatable_diagnostic)] +// #![deny(rustc::untranslatable_diagnostic)] #![deny(rustc::diagnostic_outside_of_impl)] #[macro_use] diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs index 718ec14db36..af1741bad6c 100644 --- a/compiler/rustc_query_system/src/query/job.rs +++ b/compiler/rustc_query_system/src/query/job.rs @@ -1,3 +1,4 @@ +use crate::error::CycleStack; use crate::query::plumbing::CycleError; use crate::query::{QueryContext, QueryStackFrame}; @@ -535,26 +536,42 @@ pub(crate) fn report_cycle<'a>( let span = stack[0].query.default_span(stack[1 % stack.len()].span); - let mut cycle_diag = crate::error::Cycle { - span, - upper_stack_info: Vec::with_capacity(stack.len() - 1), - stack_bottom: stack[0].query.description.to_owned(), - recursive_ty_alias: false, - recursive_trait_alias: false, - cycle_usage: usage.map(|(span, query)| (query.default_span(span), query.description)), - }; + let mut cycle_stack = Vec::new(); + + use crate::error::StackCount; + let stack_count = if stack.len() == 1 { StackCount::Single } else { StackCount::Multiple }; for i in 1..stack.len() { let query = &stack[i].query; let span = query.default_span(stack[(i + 1) % stack.len()].span); - cycle_diag.upper_stack_info.push((span, query.description.to_owned())); + cycle_stack.push(CycleStack { span, desc: query.description.to_owned() }); } - if stack.iter().all(|entry| entry.query.def_kind == Some(DefKind::TyAlias)) { - cycle_diag.recursive_ty_alias = true; - } else if stack.iter().all(|entry| entry.query.def_kind == Some(DefKind::TraitAlias)) { - cycle_diag.recursive_trait_alias = true; + let mut cycle_usage = None; + if let Some((span, query)) = usage { + cycle_usage = Some(crate::error::CycleUsage { + span: query.default_span(span), + usage: query.description, + }); } + // let cycle_usage = usage.map(|(span, query)| query.default_span(span)) + + let alias = if stack.iter().all(|entry| entry.query.def_kind == Some(DefKind::TyAlias)) { + Some(crate::error::Alias::Ty) + } else if stack.iter().all(|entry| entry.query.def_kind == Some(DefKind::TraitAlias)) { + Some(crate::error::Alias::Trait) + } else { + None + }; + + let cycle_diag = crate::error::Cycle { + span, + cycle_stack, + stack_bottom: stack[0].query.description.to_owned(), + alias, + cycle_usage: cycle_usage, + stack_count, + }; cycle_diag.into_diagnostic(&sess.parse_sess) } diff --git a/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.rs b/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.rs index 89eaec78c6f..f0843c60543 100644 --- a/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.rs +++ b/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.rs @@ -167,8 +167,8 @@ enum P { #[derive(SessionSubdiagnostic)] enum Q { #[bar] - //~^ ERROR `#[bar]` is not a valid attribute - //~^^ ERROR cannot find attribute `bar` in this scope +//~^ ERROR `#[bar]` is not a valid attribute +//~^^ ERROR cannot find attribute `bar` in this scope A { #[primary_span] span: Span, @@ -179,8 +179,8 @@ enum Q { #[derive(SessionSubdiagnostic)] enum R { #[bar = "..."] - //~^ ERROR `#[bar = ...]` is not a valid attribute - //~^^ ERROR cannot find attribute `bar` in this scope +//~^ ERROR `#[bar = ...]` is not a valid attribute +//~^^ ERROR cannot find attribute `bar` in this scope A { #[primary_span] span: Span, @@ -191,8 +191,8 @@ enum R { #[derive(SessionSubdiagnostic)] enum S { #[bar = 4] - //~^ ERROR `#[bar = ...]` is not a valid attribute - //~^^ ERROR cannot find attribute `bar` in this scope +//~^ ERROR `#[bar = ...]` is not a valid attribute +//~^^ ERROR cannot find attribute `bar` in this scope A { #[primary_span] span: Span, @@ -203,8 +203,8 @@ enum S { #[derive(SessionSubdiagnostic)] enum T { #[bar("...")] - //~^ ERROR `#[bar(...)]` is not a valid attribute - //~^^ ERROR cannot find attribute `bar` in this scope +//~^ ERROR `#[bar("...")]` is not a valid attribute +//~^^ ERROR cannot find attribute `bar` in this scope A { #[primary_span] span: Span, @@ -215,7 +215,7 @@ enum T { #[derive(SessionSubdiagnostic)] enum U { #[label(code = "...")] - //~^ ERROR diagnostic slug must be first argument of a `#[label(...)]` attribute +//~^ ERROR diagnostic slug must be first argument of a `#[label(...)]` attribute A { #[primary_span] span: Span, @@ -232,7 +232,7 @@ enum V { var: String, }, B { - //~^ ERROR subdiagnostic kind not specified +//~^ ERROR subdiagnostic kind not specified #[primary_span] span: Span, var: String, @@ -307,16 +307,6 @@ union AC { b: u64 } -#[derive(SessionSubdiagnostic)] -#[label(parser::add_paren)] -//~^ NOTE previously specified here -#[label(parser::add_paren)] -//~^ ERROR specified multiple times -struct AD { - #[primary_span] - span: Span, -} - #[derive(SessionSubdiagnostic)] #[label(parser::add_paren, parser::add_paren)] //~^ ERROR `#[label(parser::add_paren)]` is not a valid attribute @@ -329,16 +319,16 @@ struct AE { #[label(parser::add_paren)] struct AF { #[primary_span] - //~^ NOTE previously specified here +//~^ NOTE previously specified here span_a: Span, #[primary_span] - //~^ ERROR specified multiple times +//~^ ERROR specified multiple times span_b: Span, } #[derive(SessionSubdiagnostic)] struct AG { - //~^ ERROR subdiagnostic kind not specified +//~^ ERROR subdiagnostic kind not specified #[primary_span] span: Span, } @@ -390,25 +380,27 @@ struct AK { #[primary_span] span: Span, #[applicability] - //~^ NOTE previously specified here +//~^ NOTE previously specified here applicability_a: Applicability, #[applicability] - //~^ ERROR specified multiple times +//~^ ERROR specified multiple times applicability_b: Applicability, } #[derive(SessionSubdiagnostic)] #[suggestion(parser::add_paren, code = "...")] +//~^ ERROR suggestion without `applicability` struct AL { #[primary_span] span: Span, #[applicability] - //~^ ERROR the `#[applicability]` attribute can only be applied to fields of type `Applicability` +//~^ ERROR the `#[applicability]` attribute can only be applied to fields of type `Applicability` applicability: Span, } #[derive(SessionSubdiagnostic)] #[suggestion(parser::add_paren, code = "...")] +//~^ ERROR suggestion without `applicability` struct AM { #[primary_span] span: Span, @@ -444,7 +436,8 @@ struct AQ; #[derive(SessionSubdiagnostic)] #[suggestion(parser::add_paren, code = "...")] -//~^ ERROR suggestion without `#[primary_span]` field +//~^ ERROR suggestion without `applicability` +//~^^ ERROR suggestion without `#[primary_span]` field struct AR { var: String, } @@ -514,120 +507,3 @@ struct AZ { #[primary_span] span: Span, } - -#[derive(SessionSubdiagnostic)] -#[suggestion(parser::add_paren, code = "...")] -//~^ ERROR suggestion without `#[primary_span]` field -struct BA { - #[suggestion_part] - //~^ ERROR `#[suggestion_part]` is not a valid attribute - span: Span, - #[suggestion_part(code = "...")] - //~^ ERROR `#[suggestion_part(...)]` is not a valid attribute - span2: Span, - #[applicability] - applicability: Applicability, - var: String, -} - -#[derive(SessionSubdiagnostic)] -#[multipart_suggestion(parser::add_paren, code = "...", applicability = "machine-applicable")] -//~^ ERROR multipart suggestion without any `#[suggestion_part(...)]` fields -//~| ERROR `code` is not a valid nested attribute of a `multipart_suggestion` attribute -struct BBa { - var: String, -} - -#[derive(SessionSubdiagnostic)] -#[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] -struct BBb { - #[suggestion_part] - //~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."` - span1: Span, -} - -#[derive(SessionSubdiagnostic)] -#[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] -struct BBc { - #[suggestion_part()] - //~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."` - span1: Span, -} - -#[derive(SessionSubdiagnostic)] -#[multipart_suggestion(parser::add_paren)] -//~^ ERROR multipart suggestion without any `#[suggestion_part(...)]` fields -struct BC { - #[primary_span] - //~^ ERROR `#[primary_span]` is not a valid attribute - span: Span, -} - -#[derive(SessionSubdiagnostic)] -#[multipart_suggestion(parser::add_paren)] -struct BD { - #[suggestion_part] - //~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."` - span1: Span, - #[suggestion_part()] - //~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."` - span2: Span, - #[suggestion_part(foo = "bar")] - //~^ ERROR `#[suggestion_part(foo = ...)]` is not a valid attribute - span4: Span, - #[suggestion_part(code = "...")] - //~^ ERROR the `#[suggestion_part(...)]` attribute can only be applied to fields of type `Span` or `MultiSpan` - s1: String, - #[suggestion_part()] - //~^ ERROR the `#[suggestion_part(...)]` attribute can only be applied to fields of type `Span` or `MultiSpan` - s2: String, -} - -#[derive(SessionSubdiagnostic)] -#[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] -struct BE { - #[suggestion_part(code = "...", code = ",,,")] - //~^ ERROR specified multiple times - //~| NOTE previously specified here - span: Span, -} - -#[derive(SessionSubdiagnostic)] -#[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] -struct BF { - #[suggestion_part(code = "(")] - first: Span, - #[suggestion_part(code = ")")] - second: Span, -} - -#[derive(SessionSubdiagnostic)] -#[multipart_suggestion(parser::add_paren)] -struct BG { - #[applicability] - appl: Applicability, - #[suggestion_part(code = "(")] - first: Span, - #[suggestion_part(code = ")")] - second: Span, -} - -#[derive(SessionSubdiagnostic)] -#[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] -//~^ NOTE previously specified here -struct BH { - #[applicability] - //~^ ERROR specified multiple times - appl: Applicability, - #[suggestion_part(code = "(")] - first: Span, - #[suggestion_part(code = ")")] - second: Span, -} - -#[derive(SessionSubdiagnostic)] -#[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] -struct BI { - #[suggestion_part(code = "")] - spans: Vec, -} diff --git a/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.stderr b/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.stderr index 75a34f44bbe..6bd9144dbf6 100644 --- a/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.stderr +++ b/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.stderr @@ -65,16 +65,16 @@ LL | #[label()] | ^^^^^^^^^^ error: `code` is not a valid nested attribute of a `label` attribute - --> $DIR/subdiagnostic-derive.rs:137:28 + --> $DIR/subdiagnostic-derive.rs:137:1 | LL | #[label(parser::add_paren, code = "...")] - | ^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: `applicability` is not a valid nested attribute of a `label` attribute - --> $DIR/subdiagnostic-derive.rs:146:28 + --> $DIR/subdiagnostic-derive.rs:146:1 | LL | #[label(parser::add_paren, applicability = "machine-applicable")] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: unsupported type attribute for subdiagnostic enum --> $DIR/subdiagnostic-derive.rs:155:1 @@ -100,11 +100,13 @@ error: `#[bar = ...]` is not a valid attribute LL | #[bar = 4] | ^^^^^^^^^^ -error: `#[bar(...)]` is not a valid attribute - --> $DIR/subdiagnostic-derive.rs:205:5 +error: `#[bar("...")]` is not a valid attribute + --> $DIR/subdiagnostic-derive.rs:205:11 | LL | #[bar("...")] - | ^^^^^^^^^^^^^ + | ^^^^^ + | + = help: first argument of the attribute should be the diagnostic slug error: diagnostic slug must be first argument of a `#[label(...)]` attribute --> $DIR/subdiagnostic-derive.rs:217:5 @@ -161,8 +163,6 @@ error: `#[bar(...)]` is not a valid attribute | LL | #[bar("...")] | ^^^^^^^^^^^^^ - | - = help: only `primary_span`, `applicability` and `skip_arg` are valid field attributes error: unexpected unsupported untagged union --> $DIR/subdiagnostic-derive.rs:304:1 @@ -174,20 +174,8 @@ LL | | b: u64 LL | | } | |_^ -error: specified multiple times - --> $DIR/subdiagnostic-derive.rs:313:1 - | -LL | #[label(parser::add_paren)] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | -note: previously specified here - --> $DIR/subdiagnostic-derive.rs:311:1 - | -LL | #[label(parser::add_paren)] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ - error: `#[label(parser::add_paren)]` is not a valid attribute - --> $DIR/subdiagnostic-derive.rs:321:28 + --> $DIR/subdiagnostic-derive.rs:311:28 | LL | #[label(parser::add_paren, parser::add_paren)] | ^^^^^^^^^^^^^^^^^ @@ -195,225 +183,133 @@ LL | #[label(parser::add_paren, parser::add_paren)] = help: a diagnostic slug must be the first argument to the attribute error: specified multiple times - --> $DIR/subdiagnostic-derive.rs:334:5 + --> $DIR/subdiagnostic-derive.rs:324:5 | LL | #[primary_span] | ^^^^^^^^^^^^^^^ | note: previously specified here - --> $DIR/subdiagnostic-derive.rs:331:5 + --> $DIR/subdiagnostic-derive.rs:321:5 | LL | #[primary_span] | ^^^^^^^^^^^^^^^ error: subdiagnostic kind not specified - --> $DIR/subdiagnostic-derive.rs:340:8 + --> $DIR/subdiagnostic-derive.rs:330:8 | LL | struct AG { | ^^ error: specified multiple times - --> $DIR/subdiagnostic-derive.rs:377:47 + --> $DIR/subdiagnostic-derive.rs:367:47 | LL | #[suggestion(parser::add_paren, code = "...", code = "...")] | ^^^^^^^^^^^^ | note: previously specified here - --> $DIR/subdiagnostic-derive.rs:377:33 + --> $DIR/subdiagnostic-derive.rs:367:33 | LL | #[suggestion(parser::add_paren, code = "...", code = "...")] | ^^^^^^^^^^^^ error: specified multiple times - --> $DIR/subdiagnostic-derive.rs:395:5 + --> $DIR/subdiagnostic-derive.rs:385:5 | LL | #[applicability] | ^^^^^^^^^^^^^^^^ | note: previously specified here - --> $DIR/subdiagnostic-derive.rs:392:5 + --> $DIR/subdiagnostic-derive.rs:382:5 | LL | #[applicability] | ^^^^^^^^^^^^^^^^ error: the `#[applicability]` attribute can only be applied to fields of type `Applicability` - --> $DIR/subdiagnostic-derive.rs:405:5 + --> $DIR/subdiagnostic-derive.rs:396:5 | LL | #[applicability] | ^^^^^^^^^^^^^^^^ -error: suggestion without `code = "..."` - --> $DIR/subdiagnostic-derive.rs:418:1 - | -LL | #[suggestion(parser::add_paren)] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -error: invalid applicability - --> $DIR/subdiagnostic-derive.rs:428:46 - | -LL | #[suggestion(parser::add_paren, code ="...", applicability = "foo")] - | ^^^^^^^^^^^^^^^^^^^^^ - -error: suggestion without `#[primary_span]` field - --> $DIR/subdiagnostic-derive.rs:446:1 +error: suggestion without `applicability` + --> $DIR/subdiagnostic-derive.rs:391:1 | LL | / #[suggestion(parser::add_paren, code = "...")] LL | | -LL | | struct AR { -LL | | var: String, +LL | | struct AL { +LL | | #[primary_span] +... | +LL | | applicability: Span, LL | | } | |_^ -error: unsupported type attribute for subdiagnostic enum - --> $DIR/subdiagnostic-derive.rs:460:1 - | -LL | #[label] - | ^^^^^^^^ - -error: `var` doesn't refer to a field on this type - --> $DIR/subdiagnostic-derive.rs:480:39 - | -LL | #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")] - | ^^^^^^^ - -error: `var` doesn't refer to a field on this type - --> $DIR/subdiagnostic-derive.rs:499:43 - | -LL | #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")] - | ^^^^^^^ - -error: `#[suggestion_part]` is not a valid attribute - --> $DIR/subdiagnostic-derive.rs:522:5 - | -LL | #[suggestion_part] - | ^^^^^^^^^^^^^^^^^^ - | - = help: `#[suggestion_part(...)]` is only valid in multipart suggestions, use `#[primary_span]` instead - -error: `#[suggestion_part(...)]` is not a valid attribute - --> $DIR/subdiagnostic-derive.rs:525:5 +error: suggestion without `applicability` + --> $DIR/subdiagnostic-derive.rs:402:1 | -LL | #[suggestion_part(code = "...")] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = help: `#[suggestion_part(...)]` is only valid in multipart suggestions +LL | / #[suggestion(parser::add_paren, code = "...")] +LL | | +LL | | struct AM { +LL | | #[primary_span] +LL | | span: Span, +LL | | } + | |_^ -error: suggestion without `#[primary_span]` field - --> $DIR/subdiagnostic-derive.rs:519:1 +error: suggestion without `code = "..."` + --> $DIR/subdiagnostic-derive.rs:410:1 | -LL | / #[suggestion(parser::add_paren, code = "...")] +LL | / #[suggestion(parser::add_paren)] LL | | -LL | | struct BA { -LL | | #[suggestion_part] +LL | | struct AN { +LL | | #[primary_span] ... | -LL | | var: String, +LL | | applicability: Applicability, LL | | } | |_^ -error: `code` is not a valid nested attribute of a `multipart_suggestion` attribute - --> $DIR/subdiagnostic-derive.rs:534:43 +error: invalid applicability + --> $DIR/subdiagnostic-derive.rs:420:46 | -LL | #[multipart_suggestion(parser::add_paren, code = "...", applicability = "machine-applicable")] - | ^^^^^^^^^^^^ +LL | #[suggestion(parser::add_paren, code ="...", applicability = "foo")] + | ^^^^^^^^^^^^^^^^^^^^^ -error: multipart suggestion without any `#[suggestion_part(...)]` fields - --> $DIR/subdiagnostic-derive.rs:534:1 +error: suggestion without `applicability` + --> $DIR/subdiagnostic-derive.rs:438:1 | -LL | / #[multipart_suggestion(parser::add_paren, code = "...", applicability = "machine-applicable")] +LL | / #[suggestion(parser::add_paren, code = "...")] LL | | LL | | -LL | | struct BBa { +LL | | struct AR { LL | | var: String, LL | | } | |_^ -error: `#[suggestion_part(...)]` attribute without `code = "..."` - --> $DIR/subdiagnostic-derive.rs:544:5 - | -LL | #[suggestion_part] - | ^^^^^^^^^^^^^^^^^^ - -error: `#[suggestion_part(...)]` attribute without `code = "..."` - --> $DIR/subdiagnostic-derive.rs:552:5 - | -LL | #[suggestion_part()] - | ^^^^^^^^^^^^^^^^^^^^ - -error: `#[primary_span]` is not a valid attribute - --> $DIR/subdiagnostic-derive.rs:561:5 - | -LL | #[primary_span] - | ^^^^^^^^^^^^^^^ - | - = help: multipart suggestions use one or more `#[suggestion_part]`s rather than one `#[primary_span]` - -error: multipart suggestion without any `#[suggestion_part(...)]` fields - --> $DIR/subdiagnostic-derive.rs:558:1 +error: suggestion without `#[primary_span]` field + --> $DIR/subdiagnostic-derive.rs:438:1 | -LL | / #[multipart_suggestion(parser::add_paren)] +LL | / #[suggestion(parser::add_paren, code = "...")] LL | | -LL | | struct BC { -LL | | #[primary_span] LL | | -LL | | span: Span, +LL | | struct AR { +LL | | var: String, LL | | } | |_^ -error: `#[suggestion_part(...)]` attribute without `code = "..."` - --> $DIR/subdiagnostic-derive.rs:569:5 - | -LL | #[suggestion_part] - | ^^^^^^^^^^^^^^^^^^ - -error: `#[suggestion_part(...)]` attribute without `code = "..."` - --> $DIR/subdiagnostic-derive.rs:572:5 - | -LL | #[suggestion_part()] - | ^^^^^^^^^^^^^^^^^^^^ - -error: `#[suggestion_part(foo = ...)]` is not a valid attribute - --> $DIR/subdiagnostic-derive.rs:575:23 - | -LL | #[suggestion_part(foo = "bar")] - | ^^^^^^^^^^^ - | - = help: `code` is the only valid nested attribute - -error: the `#[suggestion_part(...)]` attribute can only be applied to fields of type `Span` or `MultiSpan` - --> $DIR/subdiagnostic-derive.rs:578:5 - | -LL | #[suggestion_part(code = "...")] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -error: the `#[suggestion_part(...)]` attribute can only be applied to fields of type `Span` or `MultiSpan` - --> $DIR/subdiagnostic-derive.rs:581:5 +error: unsupported type attribute for subdiagnostic enum + --> $DIR/subdiagnostic-derive.rs:453:1 | -LL | #[suggestion_part()] - | ^^^^^^^^^^^^^^^^^^^^ +LL | #[label] + | ^^^^^^^^ -error: specified multiple times - --> $DIR/subdiagnostic-derive.rs:589:37 - | -LL | #[suggestion_part(code = "...", code = ",,,")] - | ^^^^^^^^^^^^ - | -note: previously specified here - --> $DIR/subdiagnostic-derive.rs:589:23 +error: `var` doesn't refer to a field on this type + --> $DIR/subdiagnostic-derive.rs:473:39 | -LL | #[suggestion_part(code = "...", code = ",,,")] - | ^^^^^^^^^^^^ +LL | #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")] + | ^^^^^^^ -error: specified multiple times - --> $DIR/subdiagnostic-derive.rs:619:5 - | -LL | #[applicability] - | ^^^^^^^^^^^^^^^^ - | -note: previously specified here - --> $DIR/subdiagnostic-derive.rs:616:43 +error: `var` doesn't refer to a field on this type + --> $DIR/subdiagnostic-derive.rs:492:43 | -LL | #[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")] + | ^^^^^^^ error: cannot find attribute `foo` in this scope --> $DIR/subdiagnostic-derive.rs:63:3 @@ -475,6 +371,6 @@ error[E0425]: cannot find value `slug` in module `rustc_errors::fluent` LL | #[label(slug)] | ^^^^ not found in `rustc_errors::fluent` -error: aborting due to 64 previous errors +error: aborting due to 50 previous errors For more information about this error, try `rustc --explain E0425`. -- cgit 1.4.1-3-g733a5 From 7ce59ebf496590c8b2ba3693c13e981d369add4b Mon Sep 17 00:00:00 2001 From: Li Yuanheng <520dhh@gmail.com> Date: Sat, 27 Aug 2022 11:55:38 +0800 Subject: SessionDiagnostic for QueryOverflow error --- compiler/rustc_error_messages/locales/en-US/query_system.ftl | 2 ++ compiler/rustc_error_messages/src/lib.rs | 2 +- compiler/rustc_query_system/src/error.rs | 4 ++++ compiler/rustc_query_system/src/query/mod.rs | 2 +- 4 files changed, 8 insertions(+), 2 deletions(-) (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_error_messages/locales/en-US/query_system.ftl b/compiler/rustc_error_messages/locales/en-US/query_system.ftl index 7fdecf4f381..167704e46c0 100644 --- a/compiler/rustc_error_messages/locales/en-US/query_system.ftl +++ b/compiler/rustc_error_messages/locales/en-US/query_system.ftl @@ -21,3 +21,5 @@ query_system_cycle_recursive_ty_alias_help2 = see "../locales/en-US/passes.ftl", plugin_impl => "../locales/en-US/plugin_impl.ftl", privacy => "../locales/en-US/privacy.ftl", + query_system => "../locales/en-US/query_system.ftl", save_analysis => "../locales/en-US/save_analysis.ftl", ty_utils => "../locales/en-US/ty_utils.ftl", typeck => "../locales/en-US/typeck.ftl", mir_dataflow => "../locales/en-US/mir_dataflow.ftl", - query_system => "../locales/en-US/query_system.ftl", } pub use fluent_generated::{self as fluent, DEFAULT_LOCALE_RESOURCES}; diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs index 9b808afeef6..5f992ec9e21 100644 --- a/compiler/rustc_query_system/src/error.rs +++ b/compiler/rustc_query_system/src/error.rs @@ -67,3 +67,7 @@ pub struct IncrementCompilation { pub run_cmd: String, pub dep_node: String, } + +#[derive(SessionDiagnostic)] +#[diag(query_system::query_overflow)] +pub struct QueryOverflow; diff --git a/compiler/rustc_query_system/src/query/mod.rs b/compiler/rustc_query_system/src/query/mod.rs index a1f2b081d43..c6197b9fedb 100644 --- a/compiler/rustc_query_system/src/query/mod.rs +++ b/compiler/rustc_query_system/src/query/mod.rs @@ -125,6 +125,6 @@ pub trait QueryContext: HasDepContext { ) -> R; fn depth_limit_error(&self) { - self.dep_context().sess().fatal("queries overflow the depth limit!"); + self.dep_context().sess().emit_fatal(crate::error::QueryOverflow); } } -- cgit 1.4.1-3-g733a5 From 4856affd90df68b0b56dee73c431e9d9cdfc977a Mon Sep 17 00:00:00 2001 From: Joshua Nelson Date: Thu, 1 Sep 2022 20:43:12 -0500 Subject: Make `HandleCycleError` an enum instead of a macro-generated closure - Add a `HandleCycleError` enum to rustc_query_system, along with a `handle_cycle_error` function - Move `Value` to rustc_query_system, so `handle_cycle_error` can use it - Move the `Value` impls from rustc_query_impl to rustc_middle. This is necessary due to orphan rules. --- compiler/rustc_middle/src/lib.rs | 1 + compiler/rustc_middle/src/values.rs | 54 +++++++++++++++++++ compiler/rustc_query_impl/src/lib.rs | 3 -- compiler/rustc_query_impl/src/plumbing.rs | 24 ++++----- compiler/rustc_query_impl/src/values.rs | 65 ----------------------- compiler/rustc_query_system/src/error.rs | 7 +++ compiler/rustc_query_system/src/lib.rs | 4 ++ compiler/rustc_query_system/src/query/config.rs | 5 +- compiler/rustc_query_system/src/query/plumbing.rs | 38 +++++++++++-- compiler/rustc_query_system/src/values.rs | 14 +++++ 10 files changed, 129 insertions(+), 86 deletions(-) create mode 100644 compiler/rustc_middle/src/values.rs delete mode 100644 compiler/rustc_query_impl/src/values.rs create mode 100644 compiler/rustc_query_system/src/values.rs (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs index be9e5865e54..7edc9a16cc1 100644 --- a/compiler/rustc_middle/src/lib.rs +++ b/compiler/rustc_middle/src/lib.rs @@ -95,6 +95,7 @@ pub mod mir; pub mod thir; pub mod traits; pub mod ty; +mod values; pub mod util { pub mod bug; diff --git a/compiler/rustc_middle/src/values.rs b/compiler/rustc_middle/src/values.rs new file mode 100644 index 00000000000..7fbe9ae2a84 --- /dev/null +++ b/compiler/rustc_middle/src/values.rs @@ -0,0 +1,54 @@ +use rustc_middle::ty::{self, AdtSizedConstraint, Ty, TyCtxt}; +use rustc_query_system::Value; + +impl<'tcx> Value> for Ty<'_> { + fn from_cycle_error(tcx: TyCtxt<'tcx>) -> Self { + // SAFETY: This is never called when `Self` is not `Ty<'tcx>`. + // FIXME: Represent the above fact in the trait system somehow. + unsafe { std::mem::transmute::, Ty<'_>>(tcx.ty_error()) } + } +} + +impl<'tcx> Value> for ty::SymbolName<'_> { + fn from_cycle_error(tcx: TyCtxt<'tcx>) -> Self { + // SAFETY: This is never called when `Self` is not `SymbolName<'tcx>`. + // FIXME: Represent the above fact in the trait system somehow. + unsafe { + std::mem::transmute::, ty::SymbolName<'_>>(ty::SymbolName::new( + tcx, "", + )) + } + } +} + +impl<'tcx> Value> for AdtSizedConstraint<'_> { + fn from_cycle_error(tcx: TyCtxt<'tcx>) -> Self { + // SAFETY: This is never called when `Self` is not `AdtSizedConstraint<'tcx>`. + // FIXME: Represent the above fact in the trait system somehow. + unsafe { + std::mem::transmute::, AdtSizedConstraint<'_>>( + AdtSizedConstraint(tcx.intern_type_list(&[tcx.ty_error()])), + ) + } + } +} + +impl<'tcx> Value> for ty::Binder<'_, ty::FnSig<'_>> { + fn from_cycle_error(tcx: TyCtxt<'tcx>) -> Self { + let err = tcx.ty_error(); + // FIXME(compiler-errors): It would be nice if we could get the + // query key, so we could at least generate a fn signature that + // has the right arity. + let fn_sig = ty::Binder::dummy(tcx.mk_fn_sig( + [].into_iter(), + err, + false, + rustc_hir::Unsafety::Normal, + rustc_target::spec::abi::Abi::Rust, + )); + + // SAFETY: This is never called when `Self` is not `ty::Binder<'tcx, ty::FnSig<'tcx>>`. + // FIXME: Represent the above fact in the trait system somehow. + unsafe { std::mem::transmute::, ty::Binder<'_, ty::FnSig<'_>>>(fn_sig) } + } +} diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs index 8ea09880694..26d397f70e0 100644 --- a/compiler/rustc_query_impl/src/lib.rs +++ b/compiler/rustc_query_impl/src/lib.rs @@ -34,9 +34,6 @@ pub use rustc_query_system::query::{deadlock, QueryContext}; mod keys; use keys::Key; -mod values; -use self::values::Value; - pub use rustc_query_system::query::QueryConfig; pub(crate) use rustc_query_system::query::{QueryDescription, QueryVTable}; diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs index 274df5b5e5e..1e375deb20d 100644 --- a/compiler/rustc_query_impl/src/plumbing.rs +++ b/compiler/rustc_query_impl/src/plumbing.rs @@ -18,6 +18,7 @@ use rustc_query_system::query::{ force_query, QueryConfig, QueryContext, QueryDescription, QueryJobId, QueryMap, QuerySideEffects, QueryStackFrame, }; +use rustc_query_system::Value; use std::any::Any; use std::num::NonZeroU64; use thin_vec::ThinVec; @@ -174,21 +175,17 @@ impl<'tcx> QueryCtxt<'tcx> { } macro_rules! handle_cycle_error { - ([][$tcx: expr, $error:expr]) => {{ - $error.emit(); - Value::from_cycle_error($tcx) + ([]) => {{ + rustc_query_system::HandleCycleError::Error }}; - ([(fatal_cycle) $($rest:tt)*][$tcx:expr, $error:expr]) => {{ - $error.emit(); - $tcx.sess.abort_if_errors(); - unreachable!() + ([(fatal_cycle) $($rest:tt)*]) => {{ + rustc_query_system::HandleCycleError::Fatal }}; - ([(cycle_delay_bug) $($rest:tt)*][$tcx:expr, $error:expr]) => {{ - $error.delay_as_bug(); - Value::from_cycle_error($tcx) + ([(cycle_delay_bug) $($rest:tt)*]) => {{ + rustc_query_system::HandleCycleError::DelayBug }}; - ([$other:tt $($modifiers:tt)*][$($args:tt)*]) => { - handle_cycle_error!([$($modifiers)*][$($args)*]) + ([$other:tt $($modifiers:tt)*]) => { + handle_cycle_error!([$($modifiers)*]) }; } @@ -320,6 +317,7 @@ fn force_from_dep_node<'tcx, Q>(tcx: TyCtxt<'tcx>, dep_node: DepNode) -> bool where Q: QueryDescription>, Q::Key: DepNodeParams>, + Q::Value: Value>, { if let Some(key) = Q::Key::recover(tcx, &dep_node) { #[cfg(debug_assertions)] @@ -418,7 +416,7 @@ macro_rules! define_queries { depth_limit: depth_limit!([$($modifiers)*]), dep_kind: dep_graph::DepKind::$name, hash_result: hash_result!([$($modifiers)*]), - handle_cycle_error: |tcx, mut error| handle_cycle_error!([$($modifiers)*][tcx, error]), + handle_cycle_error: handle_cycle_error!([$($modifiers)*]), compute, cache_on_disk, try_load_from_disk: Self::TRY_LOAD_FROM_DISK, diff --git a/compiler/rustc_query_impl/src/values.rs b/compiler/rustc_query_impl/src/values.rs deleted file mode 100644 index 0ed48f8d4a0..00000000000 --- a/compiler/rustc_query_impl/src/values.rs +++ /dev/null @@ -1,65 +0,0 @@ -use super::QueryCtxt; -use rustc_middle::ty::{self, AdtSizedConstraint, Ty}; - -pub(super) trait Value<'tcx>: Sized { - fn from_cycle_error(tcx: QueryCtxt<'tcx>) -> Self; -} - -impl<'tcx, T> Value<'tcx> for T { - default fn from_cycle_error(tcx: QueryCtxt<'tcx>) -> T { - tcx.sess.abort_if_errors(); - bug!("Value::from_cycle_error called without errors"); - } -} - -impl<'tcx> Value<'tcx> for Ty<'_> { - fn from_cycle_error(tcx: QueryCtxt<'tcx>) -> Self { - // SAFETY: This is never called when `Self` is not `Ty<'tcx>`. - // FIXME: Represent the above fact in the trait system somehow. - unsafe { std::mem::transmute::, Ty<'_>>(tcx.ty_error()) } - } -} - -impl<'tcx> Value<'tcx> for ty::SymbolName<'_> { - fn from_cycle_error(tcx: QueryCtxt<'tcx>) -> Self { - // SAFETY: This is never called when `Self` is not `SymbolName<'tcx>`. - // FIXME: Represent the above fact in the trait system somehow. - unsafe { - std::mem::transmute::, ty::SymbolName<'_>>(ty::SymbolName::new( - *tcx, "", - )) - } - } -} - -impl<'tcx> Value<'tcx> for AdtSizedConstraint<'_> { - fn from_cycle_error(tcx: QueryCtxt<'tcx>) -> Self { - // SAFETY: This is never called when `Self` is not `AdtSizedConstraint<'tcx>`. - // FIXME: Represent the above fact in the trait system somehow. - unsafe { - std::mem::transmute::, AdtSizedConstraint<'_>>( - AdtSizedConstraint(tcx.intern_type_list(&[tcx.ty_error()])), - ) - } - } -} - -impl<'tcx> Value<'tcx> for ty::Binder<'_, ty::FnSig<'_>> { - fn from_cycle_error(tcx: QueryCtxt<'tcx>) -> Self { - let err = tcx.ty_error(); - // FIXME(compiler-errors): It would be nice if we could get the - // query key, so we could at least generate a fn signature that - // has the right arity. - let fn_sig = ty::Binder::dummy(tcx.mk_fn_sig( - [].into_iter(), - err, - false, - rustc_hir::Unsafety::Normal, - rustc_target::spec::abi::Abi::Rust, - )); - - // SAFETY: This is never called when `Self` is not `ty::Binder<'tcx, ty::FnSig<'tcx>>`. - // FIXME: Represent the above fact in the trait system somehow. - unsafe { std::mem::transmute::, ty::Binder<'_, ty::FnSig<'_>>>(fn_sig) } - } -} diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs index 5f992ec9e21..3fb06cbedbd 100644 --- a/compiler/rustc_query_system/src/error.rs +++ b/compiler/rustc_query_system/src/error.rs @@ -12,6 +12,13 @@ impl AddSubdiagnostic for CycleStack { } } +#[derive(Copy, Clone)] +pub enum HandleCycleError { + Error, + Fatal, + DelayBug, +} + #[derive(SessionSubdiagnostic)] pub enum StackCount { #[note(query_system::cycle_stack_single)] diff --git a/compiler/rustc_query_system/src/lib.rs b/compiler/rustc_query_system/src/lib.rs index 7067bc5f09c..8a88b5c3340 100644 --- a/compiler/rustc_query_system/src/lib.rs +++ b/compiler/rustc_query_system/src/lib.rs @@ -20,3 +20,7 @@ pub mod dep_graph; mod error; pub mod ich; pub mod query; +mod values; + +pub use error::HandleCycleError; +pub use values::Value; diff --git a/compiler/rustc_query_system/src/query/config.rs b/compiler/rustc_query_system/src/query/config.rs index ea38df836cb..c63e110a62e 100644 --- a/compiler/rustc_query_system/src/query/config.rs +++ b/compiler/rustc_query_system/src/query/config.rs @@ -2,12 +2,12 @@ use crate::dep_graph::DepNode; use crate::dep_graph::SerializedDepNodeIndex; +use crate::error::HandleCycleError; use crate::ich::StableHashingContext; use crate::query::caches::QueryCache; use crate::query::{QueryContext, QueryState}; use rustc_data_structures::fingerprint::Fingerprint; -use rustc_errors::{DiagnosticBuilder, ErrorGuaranteed}; use std::fmt::Debug; use std::hash::Hash; @@ -19,6 +19,7 @@ pub trait QueryConfig { type Stored: Clone; } +#[derive(Copy, Clone)] pub struct QueryVTable { pub anon: bool, pub dep_kind: CTX::DepKind, @@ -28,7 +29,7 @@ pub struct QueryVTable { pub compute: fn(CTX::DepContext, K) -> V, pub hash_result: Option, &V) -> Fingerprint>, - pub handle_cycle_error: fn(CTX, DiagnosticBuilder<'_, ErrorGuaranteed>) -> V, + pub handle_cycle_error: HandleCycleError, pub try_load_from_disk: Option Option>, } diff --git a/compiler/rustc_query_system/src/query/plumbing.rs b/compiler/rustc_query_system/src/query/plumbing.rs index 7bbc22e8293..e39e39860cb 100644 --- a/compiler/rustc_query_system/src/query/plumbing.rs +++ b/compiler/rustc_query_system/src/query/plumbing.rs @@ -7,6 +7,8 @@ use crate::query::caches::QueryCache; use crate::query::config::{QueryDescription, QueryVTable}; use crate::query::job::{report_cycle, QueryInfo, QueryJob, QueryJobId, QueryJobInfo}; use crate::query::{QueryContext, QueryMap, QuerySideEffects, QueryStackFrame}; +use crate::values::Value; +use crate::HandleCycleError; use rustc_data_structures::fingerprint::Fingerprint; use rustc_data_structures::fx::FxHashMap; #[cfg(parallel_compiler)] @@ -118,19 +120,46 @@ where fn mk_cycle( tcx: CTX, error: CycleError, - handle_cycle_error: fn(CTX, DiagnosticBuilder<'_, ErrorGuaranteed>) -> V, + handler: HandleCycleError, cache: &dyn crate::query::QueryStorage, ) -> R where CTX: QueryContext, - V: std::fmt::Debug, + V: std::fmt::Debug + Value, R: Clone, { let error = report_cycle(tcx.dep_context().sess(), error); - let value = handle_cycle_error(tcx, error); + let value = handle_cycle_error(*tcx.dep_context(), error, handler); cache.store_nocache(value) } +fn handle_cycle_error( + tcx: CTX, + mut error: DiagnosticBuilder<'_, ErrorGuaranteed>, + handler: HandleCycleError, +) -> V +where + CTX: DepContext, + V: Value, +{ + use HandleCycleError::*; + match handler { + Error => { + error.emit(); + Value::from_cycle_error(tcx) + } + Fatal => { + error.emit(); + tcx.sess().abort_if_errors(); + unreachable!() + } + DelayBug => { + error.delay_as_bug(); + Value::from_cycle_error(tcx) + } + } +} + impl<'tcx, K> JobOwner<'tcx, K> where K: Eq + Hash + Clone, @@ -336,6 +365,7 @@ fn try_execute_query( where C: QueryCache, C::Key: Clone + DepNodeParams, + C::Value: Value, CTX: QueryContext, { match JobOwner::<'_, C::Key>::try_start(&tcx, state, span, key.clone()) { @@ -686,6 +716,7 @@ pub fn get_query(tcx: CTX, span: Span, key: Q::Key, mode: QueryMode) -> where Q: QueryDescription, Q::Key: DepNodeParams, + Q::Value: Value, CTX: QueryContext, { let query = Q::make_vtable(tcx, &key); @@ -718,6 +749,7 @@ pub fn force_query(tcx: CTX, key: Q::Key, dep_node: DepNode, Q::Key: DepNodeParams, + Q::Value: Value, CTX: QueryContext, { // We may be concurrently trying both execute and force a query. diff --git a/compiler/rustc_query_system/src/values.rs b/compiler/rustc_query_system/src/values.rs new file mode 100644 index 00000000000..aeef66f86da --- /dev/null +++ b/compiler/rustc_query_system/src/values.rs @@ -0,0 +1,14 @@ +use crate::dep_graph::DepContext; + +pub trait Value: Sized { + fn from_cycle_error(tcx: CTX) -> Self; +} + +impl Value for T { + default fn from_cycle_error(tcx: CTX) -> T { + tcx.sess().abort_if_errors(); + // Ideally we would use `bug!` here. But bug! is only defined in rustc_middle, and it's + // non-trivial to define it earlier. + panic!("Value::from_cycle_error called without errors"); + } +} -- cgit 1.4.1-3-g733a5 From 44506f38e079caec1b6c14e05a9b86e19544757f Mon Sep 17 00:00:00 2001 From: SparrowLii Date: Wed, 14 Sep 2022 21:00:00 +0800 Subject: add note for `layout_of` when query depth overflows --- .../locales/en-US/query_system.ftl | 2 ++ compiler/rustc_query_impl/src/plumbing.rs | 2 +- compiler/rustc_query_system/src/error.rs | 14 ++++++++++++- compiler/rustc_query_system/src/query/job.rs | 24 +++++++++++++++++++++- compiler/rustc_query_system/src/query/mod.rs | 15 ++++++++++++-- 5 files changed, 52 insertions(+), 5 deletions(-) (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_error_messages/locales/en-US/query_system.ftl b/compiler/rustc_error_messages/locales/en-US/query_system.ftl index 167704e46c0..050a41fc7f9 100644 --- a/compiler/rustc_error_messages/locales/en-US/query_system.ftl +++ b/compiler/rustc_error_messages/locales/en-US/query_system.ftl @@ -23,3 +23,5 @@ query_system_cycle_recursive_trait_alias = trait aliases cannot be recursive query_system_cycle_which_requires = ...which requires {$desc}... query_system_query_overflow = queries overflow the depth limit! + +query_system_layout_of_depth = Query depth increased by {$depth} when {$desc}! diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs index 6fb3c69b1f4..3ca657cbca1 100644 --- a/compiler/rustc_query_impl/src/plumbing.rs +++ b/compiler/rustc_query_impl/src/plumbing.rs @@ -109,7 +109,7 @@ impl QueryContext for QueryCtxt<'_> { // when accessing the `ImplicitCtxt`. tls::with_related_context(**self, move |current_icx| { if depth_limit && !self.recursion_limit().value_within_limit(current_icx.query_depth) { - self.depth_limit_error(); + self.depth_limit_error(token); } // Update the `ImplicitCtxt` to point to our new query job. diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs index 3fb06cbedbd..5f57a1510aa 100644 --- a/compiler/rustc_query_system/src/error.rs +++ b/compiler/rustc_query_system/src/error.rs @@ -77,4 +77,16 @@ pub struct IncrementCompilation { #[derive(SessionDiagnostic)] #[diag(query_system::query_overflow)] -pub struct QueryOverflow; +pub struct QueryOverflow { + #[subdiagnostic] + pub layout_of_depth: Option, +} + +#[derive(SessionSubdiagnostic)] +#[note(query_system::layout_of_depth)] +pub struct LayoutOfDepth { + #[primary_span] + pub span: Span, + pub desc: String, + pub depth: usize, +} diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs index 45b4079fb54..a5ea3a098a6 100644 --- a/compiler/rustc_query_system/src/query/job.rs +++ b/compiler/rustc_query_system/src/query/job.rs @@ -59,6 +59,7 @@ impl QueryJobId { } } +#[derive(Clone)] pub struct QueryJobInfo { pub query: QueryStackFrame, pub job: QueryJob, @@ -116,10 +117,10 @@ impl QueryJob { } } -#[cfg(not(parallel_compiler))] impl QueryJobId { #[cold] #[inline(never)] + #[cfg(not(parallel_compiler))] pub(super) fn find_cycle_in_stack( &self, query_map: QueryMap, @@ -156,6 +157,27 @@ impl QueryJobId { panic!("did not find a cycle") } + + #[cold] + #[inline(never)] + pub(super) fn try_find_layout_root( + &self, + query_map: QueryMap, + ) -> Option<(QueryJobInfo, usize)> { + let mut last_layout = None; + let mut current_id = Some(*self); + let mut depth = 0; + + while let Some(id) = current_id { + let info = query_map.get(&id).unwrap(); + if info.query.name == "layout_of" { + depth += 1; + last_layout = Some((info.clone(), depth)); + } + current_id = info.job.parent; + } + last_layout + } } #[cfg(parallel_compiler)] diff --git a/compiler/rustc_query_system/src/query/mod.rs b/compiler/rustc_query_system/src/query/mod.rs index 0b07bb64b6a..e29e8815331 100644 --- a/compiler/rustc_query_system/src/query/mod.rs +++ b/compiler/rustc_query_system/src/query/mod.rs @@ -123,7 +123,18 @@ pub trait QueryContext: HasDepContext { compute: impl FnOnce() -> R, ) -> R; - fn depth_limit_error(&self) { - self.dep_context().sess().emit_fatal(crate::error::QueryOverflow); + fn depth_limit_error(&self, job: QueryJobId) { + let sess = self.dep_context().sess(); + let mut layout_of_depth = None; + if let Some(map) = self.try_collect_active_jobs() { + if let Some((info, depth)) = job.try_find_layout_root(map) { + layout_of_depth = Some(crate::error::LayoutOfDepth { + span: info.job.span, + desc: info.query.description, + depth, + }); + } + } + sess.emit_fatal(crate::error::QueryOverflow { layout_of_depth }); } } -- cgit 1.4.1-3-g733a5 From 89fd6ae458c96f7c3be00d93861ed3f0aa53d95b Mon Sep 17 00:00:00 2001 From: SparrowLii Date: Thu, 15 Sep 2022 15:45:17 +0800 Subject: correct span, add help message and add UI test when query depth overflows --- .../locales/en-US/query_system.ftl | 3 ++- compiler/rustc_query_impl/src/plumbing.rs | 27 ++++++++++++++++++- compiler/rustc_query_system/src/error.rs | 10 ++++--- compiler/rustc_query_system/src/lib.rs | 2 ++ compiler/rustc_query_system/src/query/job.rs | 5 +--- compiler/rustc_query_system/src/query/mod.rs | 17 ++---------- src/test/ui/query-system/query_depth.rs | 31 ++++++++++++++++++++++ src/test/ui/query-system/query_depth.stderr | 11 ++++++++ 8 files changed, 82 insertions(+), 24 deletions(-) create mode 100644 src/test/ui/query-system/query_depth.rs create mode 100644 src/test/ui/query-system/query_depth.stderr (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_error_messages/locales/en-US/query_system.ftl b/compiler/rustc_error_messages/locales/en-US/query_system.ftl index 050a41fc7f9..b914ba52a73 100644 --- a/compiler/rustc_error_messages/locales/en-US/query_system.ftl +++ b/compiler/rustc_error_messages/locales/en-US/query_system.ftl @@ -23,5 +23,6 @@ query_system_cycle_recursive_trait_alias = trait aliases cannot be recursive query_system_cycle_which_requires = ...which requires {$desc}... query_system_query_overflow = queries overflow the depth limit! + .help = consider increasing the recursion limit by adding a `#![recursion_limit = "{$suggested_limit}"]` attribute to your crate (`{$crate_name}`) -query_system_layout_of_depth = Query depth increased by {$depth} when {$desc}! +query_system_layout_of_depth = query depth increased by {$depth} when {$desc} diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs index 3ca657cbca1..b9edb757b56 100644 --- a/compiler/rustc_query_impl/src/plumbing.rs +++ b/compiler/rustc_query_impl/src/plumbing.rs @@ -19,8 +19,10 @@ use rustc_query_system::query::{ force_query, QueryConfig, QueryContext, QueryDescription, QueryJobId, QueryMap, QuerySideEffects, QueryStackFrame, }; -use rustc_query_system::Value; +use rustc_query_system::{LayoutOfDepth, QueryOverflow, Value}; use rustc_serialize::Decodable; +use rustc_session::Limit; +use rustc_span::def_id::LOCAL_CRATE; use std::any::Any; use std::num::NonZeroU64; use thin_vec::ThinVec; @@ -127,6 +129,29 @@ impl QueryContext for QueryCtxt<'_> { }) }) } + + fn depth_limit_error(&self, job: QueryJobId) { + let mut span = None; + let mut layout_of_depth = None; + if let Some(map) = self.try_collect_active_jobs() { + if let Some((info, depth)) = job.try_find_layout_root(map) { + span = Some(info.job.span); + layout_of_depth = Some(LayoutOfDepth { desc: info.query.description, depth }); + } + } + + let suggested_limit = match self.recursion_limit() { + Limit(0) => Limit(2), + limit => limit * 2, + }; + + self.sess.emit_fatal(QueryOverflow { + span, + layout_of_depth, + suggested_limit, + crate_name: self.crate_name(LOCAL_CRATE), + }); + } } impl<'tcx> QueryCtxt<'tcx> { diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs index 5f57a1510aa..bececca7585 100644 --- a/compiler/rustc_query_system/src/error.rs +++ b/compiler/rustc_query_system/src/error.rs @@ -1,5 +1,6 @@ use rustc_errors::AddSubdiagnostic; -use rustc_span::Span; +use rustc_session::Limit; +use rustc_span::{Span, Symbol}; pub struct CycleStack { pub span: Span, @@ -76,17 +77,20 @@ pub struct IncrementCompilation { } #[derive(SessionDiagnostic)] +#[help] #[diag(query_system::query_overflow)] pub struct QueryOverflow { + #[primary_span] + pub span: Option, #[subdiagnostic] pub layout_of_depth: Option, + pub suggested_limit: Limit, + pub crate_name: Symbol, } #[derive(SessionSubdiagnostic)] #[note(query_system::layout_of_depth)] pub struct LayoutOfDepth { - #[primary_span] - pub span: Span, pub desc: String, pub depth: usize, } diff --git a/compiler/rustc_query_system/src/lib.rs b/compiler/rustc_query_system/src/lib.rs index 8a88b5c3340..78b06f520a8 100644 --- a/compiler/rustc_query_system/src/lib.rs +++ b/compiler/rustc_query_system/src/lib.rs @@ -23,4 +23,6 @@ pub mod query; mod values; pub use error::HandleCycleError; +pub use error::LayoutOfDepth; +pub use error::QueryOverflow; pub use values::Value; diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs index a5ea3a098a6..95305eabd0d 100644 --- a/compiler/rustc_query_system/src/query/job.rs +++ b/compiler/rustc_query_system/src/query/job.rs @@ -160,10 +160,7 @@ impl QueryJobId { #[cold] #[inline(never)] - pub(super) fn try_find_layout_root( - &self, - query_map: QueryMap, - ) -> Option<(QueryJobInfo, usize)> { + pub fn try_find_layout_root(&self, query_map: QueryMap) -> Option<(QueryJobInfo, usize)> { let mut last_layout = None; let mut current_id = Some(*self); let mut depth = 0; diff --git a/compiler/rustc_query_system/src/query/mod.rs b/compiler/rustc_query_system/src/query/mod.rs index e29e8815331..7a96c53b604 100644 --- a/compiler/rustc_query_system/src/query/mod.rs +++ b/compiler/rustc_query_system/src/query/mod.rs @@ -14,7 +14,7 @@ pub use self::caches::{ mod config; pub use self::config::{QueryConfig, QueryDescription, QueryVTable}; -use crate::dep_graph::{DepContext, DepNodeIndex, HasDepContext, SerializedDepNodeIndex}; +use crate::dep_graph::{DepNodeIndex, HasDepContext, SerializedDepNodeIndex}; use rustc_data_structures::sync::Lock; use rustc_errors::Diagnostic; use rustc_hir::def::DefKind; @@ -123,18 +123,5 @@ pub trait QueryContext: HasDepContext { compute: impl FnOnce() -> R, ) -> R; - fn depth_limit_error(&self, job: QueryJobId) { - let sess = self.dep_context().sess(); - let mut layout_of_depth = None; - if let Some(map) = self.try_collect_active_jobs() { - if let Some((info, depth)) = job.try_find_layout_root(map) { - layout_of_depth = Some(crate::error::LayoutOfDepth { - span: info.job.span, - desc: info.query.description, - depth, - }); - } - } - sess.emit_fatal(crate::error::QueryOverflow { layout_of_depth }); - } + fn depth_limit_error(&self, job: QueryJobId); } diff --git a/src/test/ui/query-system/query_depth.rs b/src/test/ui/query-system/query_depth.rs new file mode 100644 index 00000000000..e600c1c08e5 --- /dev/null +++ b/src/test/ui/query-system/query_depth.rs @@ -0,0 +1,31 @@ +// build-fail + +#![recursion_limit = "64"] +type Byte = Option + >>>> >>>> + >>>> >>>> + >>>> >>>> + >>>> >>>> + >>>> >>>> + >>>> >>>> + >>>> >>>> + >>>> >>>> + >>>> >>>> + >>>> >>>> +>>>> >>>>; + +fn main() { +//~^ ERROR: queries overflow the depth limit! + println!("{}", std::mem::size_of::()); +} diff --git a/src/test/ui/query-system/query_depth.stderr b/src/test/ui/query-system/query_depth.stderr new file mode 100644 index 00000000000..43a18b4e074 --- /dev/null +++ b/src/test/ui/query-system/query_depth.stderr @@ -0,0 +1,11 @@ +error: queries overflow the depth limit! + --> $DIR/query_depth.rs:28:1 + | +LL | fn main() { + | ^^^^^^^^^ + | + = help: consider increasing the recursion limit by adding a `#![recursion_limit = "128"]` attribute to your crate (`query_depth`) + = note: query depth increased by 66 when computing layout of `core::option::Option>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>` + +error: aborting due to previous error + -- cgit 1.4.1-3-g733a5 From 19b348fed44342d8addbbb5e8f67cda5dc8d9b95 Mon Sep 17 00:00:00 2001 From: Jhonny Bill Mena Date: Sun, 18 Sep 2022 11:45:41 -0400 Subject: UPDATE - rename DiagnosticHandler trait to IntoDiagnostic --- compiler/rustc_ast_lowering/src/errors.rs | 66 ++++----- compiler/rustc_ast_passes/src/errors.rs | 54 +++---- compiler/rustc_attr/src/session_diagnostics.rs | 68 ++++----- compiler/rustc_borrowck/src/session_diagnostics.rs | 16 +-- compiler/rustc_builtin_macros/src/cfg.rs | 6 +- compiler/rustc_const_eval/src/errors.rs | 44 +++--- compiler/rustc_driver/src/session_diagnostics.rs | 16 +-- .../rustc_error_messages/locales/en-US/lint.ftl | 2 +- compiler/rustc_errors/src/diagnostic.rs | 2 +- compiler/rustc_errors/src/diagnostic_builder.rs | 7 +- compiler/rustc_errors/src/lib.rs | 75 +++++++++- compiler/rustc_expand/src/base.rs | 6 +- compiler/rustc_expand/src/errors.rs | 14 +- .../src/infer/error_reporting/need_type_info.rs | 2 +- compiler/rustc_interface/src/errors.rs | 30 ++-- compiler/rustc_lint/src/errors.rs | 22 +-- compiler/rustc_lint/src/internal.rs | 4 +- .../rustc_macros/src/diagnostics/diagnostic.rs | 22 +-- .../src/diagnostics/diagnostic_builder.rs | 6 +- compiler/rustc_macros/src/diagnostics/mod.rs | 8 +- compiler/rustc_macros/src/lib.rs | 2 +- compiler/rustc_metadata/src/errors.rs | 158 ++++++++++----------- compiler/rustc_middle/src/error.rs | 8 +- compiler/rustc_mir_dataflow/src/errors.rs | 22 +-- compiler/rustc_monomorphize/src/errors.rs | 16 +-- compiler/rustc_parse/src/parser/diagnostics.rs | 84 +++++------ compiler/rustc_parse/src/parser/expr.rs | 2 +- compiler/rustc_passes/src/errors.rs | 104 +++++++------- compiler/rustc_plugin_impl/src/errors.rs | 6 +- compiler/rustc_privacy/src/errors.rs | 14 +- compiler/rustc_query_system/src/error.rs | 14 +- compiler/rustc_query_system/src/query/job.rs | 2 +- compiler/rustc_save_analysis/src/errors.rs | 4 +- compiler/rustc_session/src/errors.rs | 24 ++-- compiler/rustc_session/src/parse.rs | 16 +-- compiler/rustc_session/src/session.rs | 18 +-- compiler/rustc_span/src/symbol.rs | 2 +- compiler/rustc_symbol_mangling/src/errors.rs | 4 +- compiler/rustc_trait_selection/src/errors.rs | 18 +-- compiler/rustc_ty_utils/src/errors.rs | 6 +- compiler/rustc_typeck/src/check/expr.rs | 2 +- compiler/rustc_typeck/src/errors.rs | 58 ++++---- src/test/ui-fulldeps/internal-lints/diagnostics.rs | 15 +- .../ui-fulldeps/internal-lints/diagnostics.stderr | 4 +- .../session-diagnostic/diagnostic-derive.rs | 154 ++++++++++---------- .../session-diagnostic/diagnostic-derive.stderr | 16 +-- 46 files changed, 659 insertions(+), 584 deletions(-) (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs index c87d0ca9657..3f3024eb2b8 100644 --- a/compiler/rustc_ast_lowering/src/errors.rs +++ b/compiler/rustc_ast_lowering/src/errors.rs @@ -1,8 +1,8 @@ use rustc_errors::{fluent, AddSubdiagnostic, Applicability, Diagnostic, DiagnosticArgFromDisplay}; -use rustc_macros::{SessionDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{DiagnosticHandler, SessionSubdiagnostic}; use rustc_span::{symbol::Ident, Span, Symbol}; -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::generic_type_with_parentheses, code = "E0214")] pub struct GenericTypeWithParentheses { #[primary_span] @@ -28,7 +28,7 @@ impl AddSubdiagnostic for UseAngleBrackets { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[help] #[diag(ast_lowering::invalid_abi, code = "E0703")] pub struct InvalidAbi { @@ -39,7 +39,7 @@ pub struct InvalidAbi { pub valid_abis: String, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::assoc_ty_parentheses)] pub struct AssocTyParentheses { #[primary_span] @@ -71,7 +71,7 @@ impl AddSubdiagnostic for AssocTyParenthesesSub { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(ast_lowering::misplaced_impl_trait, code = "E0562")] pub struct MisplacedImplTrait<'a> { #[primary_span] @@ -79,14 +79,14 @@ pub struct MisplacedImplTrait<'a> { pub position: DiagnosticArgFromDisplay<'a>, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::rustc_box_attribute_error)] pub struct RustcBoxAttributeError { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::underscore_expr_lhs_assign)] pub struct UnderscoreExprLhsAssign { #[primary_span] @@ -94,7 +94,7 @@ pub struct UnderscoreExprLhsAssign { pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::base_expression_double_dot)] pub struct BaseExpressionDoubleDot { #[primary_span] @@ -102,7 +102,7 @@ pub struct BaseExpressionDoubleDot { pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::await_only_in_async_fn_and_blocks, code = "E0728")] pub struct AwaitOnlyInAsyncFnAndBlocks { #[primary_span] @@ -112,21 +112,21 @@ pub struct AwaitOnlyInAsyncFnAndBlocks { pub item_span: Option, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::generator_too_many_parameters, code = "E0628")] pub struct GeneratorTooManyParameters { #[primary_span] pub fn_decl_span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::closure_cannot_be_static, code = "E0697")] pub struct ClosureCannotBeStatic { #[primary_span] pub fn_decl_span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[help] #[diag(ast_lowering::async_non_move_closure_not_supported, code = "E0708")] pub struct AsyncNonMoveClosureNotSupported { @@ -134,7 +134,7 @@ pub struct AsyncNonMoveClosureNotSupported { pub fn_decl_span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::functional_record_update_destructuring_assignment)] pub struct FunctionalRecordUpdateDestructuringAssignemnt { #[primary_span] @@ -142,28 +142,28 @@ pub struct FunctionalRecordUpdateDestructuringAssignemnt { pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::async_generators_not_supported, code = "E0727")] pub struct AsyncGeneratorsNotSupported { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::inline_asm_unsupported_target, code = "E0472")] pub struct InlineAsmUnsupportedTarget { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::att_syntax_only_x86)] pub struct AttSyntaxOnlyX86 { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::abi_specified_multiple_times)] pub struct AbiSpecifiedMultipleTimes { #[primary_span] @@ -175,14 +175,14 @@ pub struct AbiSpecifiedMultipleTimes { pub equivalent: Option<()>, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::clobber_abi_not_supported)] pub struct ClobberAbiNotSupported { #[primary_span] pub abi_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[note] #[diag(ast_lowering::invalid_abi_clobber_abi)] pub struct InvalidAbiClobberAbi { @@ -191,7 +191,7 @@ pub struct InvalidAbiClobberAbi { pub supported_abis: String, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::invalid_register)] pub struct InvalidRegister<'a> { #[primary_span] @@ -200,7 +200,7 @@ pub struct InvalidRegister<'a> { pub error: &'a str, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::invalid_register_class)] pub struct InvalidRegisterClass<'a> { #[primary_span] @@ -209,7 +209,7 @@ pub struct InvalidRegisterClass<'a> { pub error: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(ast_lowering::invalid_asm_template_modifier_reg_class)] pub struct InvalidAsmTemplateModifierRegClass { #[primary_span] @@ -229,7 +229,7 @@ pub enum InvalidAsmTemplateModifierRegClassSub { DoesNotSupportModifier { class_name: Symbol }, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::invalid_asm_template_modifier_const)] pub struct InvalidAsmTemplateModifierConst { #[primary_span] @@ -239,7 +239,7 @@ pub struct InvalidAsmTemplateModifierConst { pub op_span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::invalid_asm_template_modifier_sym)] pub struct InvalidAsmTemplateModifierSym { #[primary_span] @@ -249,7 +249,7 @@ pub struct InvalidAsmTemplateModifierSym { pub op_span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::register_class_only_clobber)] pub struct RegisterClassOnlyClobber { #[primary_span] @@ -257,7 +257,7 @@ pub struct RegisterClassOnlyClobber { pub reg_class_name: Symbol, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::register_conflict)] pub struct RegisterConflict<'a> { #[primary_span] @@ -271,7 +271,7 @@ pub struct RegisterConflict<'a> { pub in_out: Option, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[help] #[diag(ast_lowering::sub_tuple_binding)] pub struct SubTupleBinding<'a> { @@ -288,7 +288,7 @@ pub struct SubTupleBinding<'a> { pub ctx: &'a str, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::extra_double_dot)] pub struct ExtraDoubleDot<'a> { #[primary_span] @@ -299,7 +299,7 @@ pub struct ExtraDoubleDot<'a> { pub ctx: &'a str, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[note] #[diag(ast_lowering::misplaced_double_dot)] pub struct MisplacedDoubleDot { @@ -307,28 +307,28 @@ pub struct MisplacedDoubleDot { pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::misplaced_relax_trait_bound)] pub struct MisplacedRelaxTraitBound { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::not_supported_for_lifetime_binder_async_closure)] pub struct NotSupportedForLifetimeBinderAsyncClosure { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::arbitrary_expression_in_pattern)] pub struct ArbitraryExpressionInPattern { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(DiagnosticHandler, Clone, Copy)] #[diag(ast_lowering::inclusive_range_with_no_end)] pub struct InclusiveRangeWithNoEnd { #[primary_span] diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs index 4f3b09c5871..20e2209acbe 100644 --- a/compiler/rustc_ast_passes/src/errors.rs +++ b/compiler/rustc_ast_passes/src/errors.rs @@ -1,12 +1,12 @@ //! Errors emitted by ast_passes. -use rustc_errors::{fluent, AddSubdiagnostic, Applicability, Diagnostic}; -use rustc_macros::{SessionDiagnostic, SessionSubdiagnostic}; +use rustc_errors::{fluent, AddToDiagnostic, Applicability, Diagnostic}; +use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_span::{Span, Symbol}; use crate::ast_validation::ForbiddenLetReason; -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::forbidden_let)] #[note] pub struct ForbiddenLet { @@ -16,7 +16,7 @@ pub struct ForbiddenLet { pub(crate) reason: ForbiddenLetReason, } -impl AddSubdiagnostic for ForbiddenLetReason { +impl AddToDiagnostic for ForbiddenLetReason { fn add_to_diagnostic(self, diag: &mut Diagnostic) { match self { Self::GenericForbidden => {} @@ -30,7 +30,7 @@ impl AddSubdiagnostic for ForbiddenLetReason { } } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::forbidden_let_stable)] #[note] pub struct ForbiddenLetStable { @@ -38,21 +38,21 @@ pub struct ForbiddenLetStable { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::forbidden_assoc_constraint)] pub struct ForbiddenAssocConstraint { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::keyword_lifetime)] pub struct KeywordLifetime { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::invalid_label)] pub struct InvalidLabel { #[primary_span] @@ -60,7 +60,7 @@ pub struct InvalidLabel { pub name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::invalid_visibility, code = "E0449")] pub struct InvalidVisibility { #[primary_span] @@ -79,7 +79,7 @@ pub enum InvalidVisibilityNote { IndividualForeignItems, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::trait_fn_const, code = "E0379")] pub struct TraitFnConst { #[primary_span] @@ -87,21 +87,21 @@ pub struct TraitFnConst { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::forbidden_lifetime_bound)] pub struct ForbiddenLifetimeBound { #[primary_span] pub spans: Vec, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::forbidden_non_lifetime_param)] pub struct ForbiddenNonLifetimeParam { #[primary_span] pub spans: Vec, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::fn_param_too_many)] pub struct FnParamTooMany { #[primary_span] @@ -109,21 +109,21 @@ pub struct FnParamTooMany { pub max_num_args: usize, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::fn_param_c_var_args_only)] pub struct FnParamCVarArgsOnly { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::fn_param_c_var_args_not_last)] pub struct FnParamCVarArgsNotLast { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::fn_param_doc_comment)] pub struct FnParamDocComment { #[primary_span] @@ -131,14 +131,14 @@ pub struct FnParamDocComment { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::fn_param_forbidden_attr)] pub struct FnParamForbiddenAttr { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::fn_param_forbidden_self)] #[note] pub struct FnParamForbiddenSelf { @@ -147,7 +147,7 @@ pub struct FnParamForbiddenSelf { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::forbidden_default)] pub struct ForbiddenDefault { #[primary_span] @@ -156,7 +156,7 @@ pub struct ForbiddenDefault { pub def_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::assoc_const_without_body)] pub struct AssocConstWithoutBody { #[primary_span] @@ -165,7 +165,7 @@ pub struct AssocConstWithoutBody { pub replace_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::assoc_fn_without_body)] pub struct AssocFnWithoutBody { #[primary_span] @@ -174,7 +174,7 @@ pub struct AssocFnWithoutBody { pub replace_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::assoc_type_without_body)] pub struct AssocTypeWithoutBody { #[primary_span] @@ -183,7 +183,7 @@ pub struct AssocTypeWithoutBody { pub replace_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::const_without_body)] pub struct ConstWithoutBody { #[primary_span] @@ -192,7 +192,7 @@ pub struct ConstWithoutBody { pub replace_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::static_without_body)] pub struct StaticWithoutBody { #[primary_span] @@ -201,7 +201,7 @@ pub struct StaticWithoutBody { pub replace_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::ty_alias_without_body)] pub struct TyAliasWithoutBody { #[primary_span] @@ -210,7 +210,7 @@ pub struct TyAliasWithoutBody { pub replace_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(ast_passes::fn_without_body)] pub struct FnWithoutBody { #[primary_span] @@ -227,7 +227,7 @@ pub struct ExternBlockSuggestion { pub abi: Option, } -impl AddSubdiagnostic for ExternBlockSuggestion { +impl AddToDiagnostic for ExternBlockSuggestion { fn add_to_diagnostic(self, diag: &mut Diagnostic) { let start_suggestion = if let Some(abi) = self.abi { format!("extern \"{}\" {{", abi) diff --git a/compiler/rustc_attr/src/session_diagnostics.rs b/compiler/rustc_attr/src/session_diagnostics.rs index ed8400391c2..8362b51af40 100644 --- a/compiler/rustc_attr/src/session_diagnostics.rs +++ b/compiler/rustc_attr/src/session_diagnostics.rs @@ -1,23 +1,23 @@ use std::num::IntErrorKind; use rustc_ast as ast; -use rustc_errors::SessionDiagnostic; use rustc_errors::{ - error_code, fluent, Applicability, DiagnosticBuilder, ErrorGuaranteed, Handler, + error_code, fluent, Applicability, DiagnosticBuilder, IntoDiagnostic, ErrorGuaranteed, + Handler, }; -use rustc_macros::SessionDiagnostic; +use rustc_macros::DiagnosticHandler; use rustc_span::{Span, Symbol}; use crate::UnsupportedLiteralReason; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::expected_one_cfg_pattern, code = "E0536")] pub(crate) struct ExpectedOneCfgPattern { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::invalid_predicate, code = "E0537")] pub(crate) struct InvalidPredicate { #[primary_span] @@ -26,7 +26,7 @@ pub(crate) struct InvalidPredicate { pub predicate: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::multiple_item, code = "E0538")] pub(crate) struct MultipleItem { #[primary_span] @@ -35,7 +35,7 @@ pub(crate) struct MultipleItem { pub item: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::incorrect_meta_item, code = "E0539")] pub(crate) struct IncorrectMetaItem { #[primary_span] @@ -50,7 +50,7 @@ pub(crate) struct UnknownMetaItem<'a> { } // Manual implementation to be able to format `expected` items correctly. -impl<'a> SessionDiagnostic<'a> for UnknownMetaItem<'_> { +impl<'a> IntoDiagnostic<'a> for UnknownMetaItem<'_> { fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> { let expected = self.expected.iter().map(|name| format!("`{}`", name)).collect::>(); let mut diag = handler.struct_span_err_with_code( @@ -65,28 +65,28 @@ impl<'a> SessionDiagnostic<'a> for UnknownMetaItem<'_> { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::missing_since, code = "E0542")] pub(crate) struct MissingSince { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::missing_note, code = "E0543")] pub(crate) struct MissingNote { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::multiple_stability_levels, code = "E0544")] pub(crate) struct MultipleStabilityLevels { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::invalid_issue_string, code = "E0545")] pub(crate) struct InvalidIssueString { #[primary_span] @@ -144,21 +144,21 @@ impl InvalidIssueStringCause { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::missing_feature, code = "E0546")] pub(crate) struct MissingFeature { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::non_ident_feature, code = "E0546")] pub(crate) struct NonIdentFeature { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::missing_issue, code = "E0547")] pub(crate) struct MissingIssue { #[primary_span] @@ -167,7 +167,7 @@ pub(crate) struct MissingIssue { // FIXME: This diagnostic is identical to `IncorrectMetaItem`, barring the error code. Consider // changing this to `IncorrectMetaItem`. See #51489. -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::incorrect_meta_item, code = "E0551")] pub(crate) struct IncorrectMetaItem2 { #[primary_span] @@ -176,14 +176,14 @@ pub(crate) struct IncorrectMetaItem2 { // FIXME: Why is this the same error code as `InvalidReprHintNoParen` and `InvalidReprHintNoValue`? // It is more similar to `IncorrectReprFormatGeneric`. -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::incorrect_repr_format_packed_one_or_zero_arg, code = "E0552")] pub(crate) struct IncorrectReprFormatPackedOneOrZeroArg { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::invalid_repr_hint_no_paren, code = "E0552")] pub(crate) struct InvalidReprHintNoParen { #[primary_span] @@ -192,7 +192,7 @@ pub(crate) struct InvalidReprHintNoParen { pub name: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::invalid_repr_hint_no_value, code = "E0552")] pub(crate) struct InvalidReprHintNoValue { #[primary_span] @@ -209,7 +209,7 @@ pub(crate) struct UnsupportedLiteral { pub start_point_span: Span, } -impl<'a> SessionDiagnostic<'a> for UnsupportedLiteral { +impl<'a> IntoDiagnostic<'a> for UnsupportedLiteral { fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> { let mut diag = handler.struct_span_err_with_code( self.span, @@ -237,7 +237,7 @@ impl<'a> SessionDiagnostic<'a> for UnsupportedLiteral { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::invalid_repr_align_need_arg, code = "E0589")] pub(crate) struct InvalidReprAlignNeedArg { #[primary_span] @@ -245,7 +245,7 @@ pub(crate) struct InvalidReprAlignNeedArg { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::invalid_repr_generic, code = "E0589")] pub(crate) struct InvalidReprGeneric<'a> { #[primary_span] @@ -255,14 +255,14 @@ pub(crate) struct InvalidReprGeneric<'a> { pub error_part: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::incorrect_repr_format_align_one_arg, code = "E0693")] pub(crate) struct IncorrectReprFormatAlignOneArg { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::incorrect_repr_format_generic, code = "E0693")] pub(crate) struct IncorrectReprFormatGeneric<'a> { #[primary_span] @@ -317,28 +317,28 @@ impl<'a> IncorrectReprFormatGenericCause<'a> { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::rustc_promotable_pairing, code = "E0717")] pub(crate) struct RustcPromotablePairing { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::rustc_allowed_unstable_pairing, code = "E0789")] pub(crate) struct RustcAllowedUnstablePairing { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::cfg_predicate_identifier)] pub(crate) struct CfgPredicateIdentifier { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::deprecated_item_suggestion)] pub(crate) struct DeprecatedItemSuggestion { #[primary_span] @@ -351,21 +351,21 @@ pub(crate) struct DeprecatedItemSuggestion { pub details: (), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::expected_single_version_literal)] pub(crate) struct ExpectedSingleVersionLiteral { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::expected_version_literal)] pub(crate) struct ExpectedVersionLiteral { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::expects_feature_list)] pub(crate) struct ExpectsFeatureList { #[primary_span] @@ -374,7 +374,7 @@ pub(crate) struct ExpectsFeatureList { pub name: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::expects_features)] pub(crate) struct ExpectsFeatures { #[primary_span] @@ -383,14 +383,14 @@ pub(crate) struct ExpectsFeatures { pub name: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::soft_no_args)] pub(crate) struct SoftNoArgs { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(attr::unknown_version_literal)] pub(crate) struct UnknownVersionLiteral { #[primary_span] diff --git a/compiler/rustc_borrowck/src/session_diagnostics.rs b/compiler/rustc_borrowck/src/session_diagnostics.rs index 5d750c6ca8c..1014a92cc39 100644 --- a/compiler/rustc_borrowck/src/session_diagnostics.rs +++ b/compiler/rustc_borrowck/src/session_diagnostics.rs @@ -1,11 +1,11 @@ use rustc_errors::{IntoDiagnosticArg, MultiSpan}; -use rustc_macros::{LintDiagnostic, SessionDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{DiagnosticHandler, LintDiagnostic, SessionSubdiagnostic}; use rustc_middle::ty::Ty; use rustc_span::Span; use crate::diagnostics::RegionName; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(borrowck::move_unsized, code = "E0161")] pub(crate) struct MoveUnsized<'tcx> { pub ty: Ty<'tcx>, @@ -14,7 +14,7 @@ pub(crate) struct MoveUnsized<'tcx> { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(borrowck::higher_ranked_lifetime_error)] pub(crate) struct HigherRankedLifetimeError { #[subdiagnostic] @@ -31,14 +31,14 @@ pub(crate) enum HigherRankedErrorCause { CouldNotNormalize { value: String }, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(borrowck::higher_ranked_subtype_error)] pub(crate) struct HigherRankedSubtypeError { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(borrowck::generic_does_not_live_long_enough)] pub(crate) struct GenericDoesNotLiveLongEnough { pub kind: String, @@ -53,7 +53,7 @@ pub(crate) struct VarNeedNotMut { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(borrowck::const_not_used_in_type_alias)] pub(crate) struct ConstNotUsedTraitAlias { pub ct: String, @@ -61,7 +61,7 @@ pub(crate) struct ConstNotUsedTraitAlias { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(borrowck::var_cannot_escape_closure)] #[note] #[note(borrowck::cannot_escape)] @@ -110,7 +110,7 @@ pub(crate) enum FnMutReturnTypeErr { }, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(borrowck::lifetime_constraints_error)] pub(crate) struct LifetimeOutliveErr { #[primary_span] diff --git a/compiler/rustc_builtin_macros/src/cfg.rs b/compiler/rustc_builtin_macros/src/cfg.rs index 9046bf13059..55b54fede93 100644 --- a/compiler/rustc_builtin_macros/src/cfg.rs +++ b/compiler/rustc_builtin_macros/src/cfg.rs @@ -8,7 +8,7 @@ use rustc_ast::tokenstream::TokenStream; use rustc_attr as attr; use rustc_errors::PResult; use rustc_expand::base::{self, *}; -use rustc_macros::SessionDiagnostic; +use rustc_macros::DiagnosticHandler; use rustc_span::Span; pub fn expand_cfg( @@ -35,7 +35,7 @@ pub fn expand_cfg( } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(builtin_macros::requires_cfg_pattern)] struct RequiresCfgPattern { #[primary_span] @@ -43,7 +43,7 @@ struct RequiresCfgPattern { span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(builtin_macros::expected_one_cfg_pattern)] struct OneCfgPattern { #[primary_span] diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs index c3547cb3abd..d0b94e91abf 100644 --- a/compiler/rustc_const_eval/src/errors.rs +++ b/compiler/rustc_const_eval/src/errors.rs @@ -1,8 +1,8 @@ use rustc_hir::ConstContext; -use rustc_macros::SessionDiagnostic; +use rustc_macros::DiagnosticHandler; use rustc_span::Span; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::unstable_in_stable)] pub(crate) struct UnstableInStable { pub gate: String, @@ -21,14 +21,14 @@ pub(crate) struct UnstableInStable { pub attr_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::thread_local_access, code = "E0625")] pub(crate) struct NonConstOpErr { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::static_access, code = "E0013")] #[help] pub(crate) struct StaticAccessErr { @@ -40,7 +40,7 @@ pub(crate) struct StaticAccessErr { pub teach: Option<()>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::raw_ptr_to_int)] #[note] #[note(const_eval::note2)] @@ -49,7 +49,7 @@ pub(crate) struct RawPtrToIntErr { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::raw_ptr_comparison)] #[note] pub(crate) struct RawPtrComparisonErr { @@ -57,14 +57,14 @@ pub(crate) struct RawPtrComparisonErr { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::panic_non_str)] pub(crate) struct PanicNonStrErr { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::mut_deref, code = "E0658")] pub(crate) struct MutDerefErr { #[primary_span] @@ -72,7 +72,7 @@ pub(crate) struct MutDerefErr { pub kind: ConstContext, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::transient_mut_borrow, code = "E0658")] pub(crate) struct TransientMutBorrowErr { #[primary_span] @@ -80,7 +80,7 @@ pub(crate) struct TransientMutBorrowErr { pub kind: ConstContext, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::transient_mut_borrow_raw, code = "E0658")] pub(crate) struct TransientMutBorrowErrRaw { #[primary_span] @@ -88,7 +88,7 @@ pub(crate) struct TransientMutBorrowErrRaw { pub kind: ConstContext, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::max_num_nodes_in_const)] pub(crate) struct MaxNumNodesInConstErr { #[primary_span] @@ -96,7 +96,7 @@ pub(crate) struct MaxNumNodesInConstErr { pub global_const_id: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::unallowed_fn_pointer_call)] pub(crate) struct UnallowedFnPointerCall { #[primary_span] @@ -104,7 +104,7 @@ pub(crate) struct UnallowedFnPointerCall { pub kind: ConstContext, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::unstable_const_fn)] pub(crate) struct UnstableConstFn { #[primary_span] @@ -112,7 +112,7 @@ pub(crate) struct UnstableConstFn { pub def_path: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::unallowed_mutable_refs, code = "E0764")] pub(crate) struct UnallowedMutableRefs { #[primary_span] @@ -122,7 +122,7 @@ pub(crate) struct UnallowedMutableRefs { pub teach: Option<()>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::unallowed_mutable_refs_raw, code = "E0764")] pub(crate) struct UnallowedMutableRefsRaw { #[primary_span] @@ -131,7 +131,7 @@ pub(crate) struct UnallowedMutableRefsRaw { #[note(const_eval::teach_note)] pub teach: Option<()>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::non_const_fmt_macro_call, code = "E0015")] pub(crate) struct NonConstFmtMacroCall { #[primary_span] @@ -139,7 +139,7 @@ pub(crate) struct NonConstFmtMacroCall { pub kind: ConstContext, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::non_const_fn_call, code = "E0015")] pub(crate) struct NonConstFnCall { #[primary_span] @@ -148,7 +148,7 @@ pub(crate) struct NonConstFnCall { pub kind: ConstContext, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::unallowed_op_in_const_context)] pub(crate) struct UnallowedOpInConstContext { #[primary_span] @@ -156,7 +156,7 @@ pub(crate) struct UnallowedOpInConstContext { pub msg: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::unallowed_heap_allocations, code = "E0010")] pub(crate) struct UnallowedHeapAllocations { #[primary_span] @@ -167,7 +167,7 @@ pub(crate) struct UnallowedHeapAllocations { pub teach: Option<()>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::unallowed_inline_asm, code = "E0015")] pub(crate) struct UnallowedInlineAsm { #[primary_span] @@ -175,7 +175,7 @@ pub(crate) struct UnallowedInlineAsm { pub kind: ConstContext, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::interior_mutable_data_refer, code = "E0492")] pub(crate) struct InteriorMutableDataRefer { #[primary_span] @@ -188,7 +188,7 @@ pub(crate) struct InteriorMutableDataRefer { pub teach: Option<()>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(const_eval::interior_mutability_borrow)] pub(crate) struct InteriorMutabilityBorrow { #[primary_span] diff --git a/compiler/rustc_driver/src/session_diagnostics.rs b/compiler/rustc_driver/src/session_diagnostics.rs index e9696792d05..704d3c7fd2a 100644 --- a/compiler/rustc_driver/src/session_diagnostics.rs +++ b/compiler/rustc_driver/src/session_diagnostics.rs @@ -1,38 +1,38 @@ -use rustc_macros::SessionDiagnostic; +use rustc_macros::DiagnosticHandler; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(driver::rlink_unable_to_read)] pub(crate) struct RlinkUnableToRead { pub err: std::io::Error, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(driver::rlink_wrong_file_type)] pub(crate) struct RLinkWrongFileType; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(driver::rlink_empty_version_number)] pub(crate) struct RLinkEmptyVersionNumber; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(driver::rlink_encoding_version_mismatch)] pub(crate) struct RLinkEncodingVersionMismatch { pub version_array: String, pub rlink_version: u32, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(driver::rlink_rustc_version_mismatch)] pub(crate) struct RLinkRustcVersionMismatch<'a> { pub rustc_version: String, pub current_version: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(driver::rlink_no_a_file)] pub(crate) struct RlinkNotAFile; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(driver::unpretty_dump_fail)] pub(crate) struct UnprettyDumpFail { pub path: String, diff --git a/compiler/rustc_error_messages/locales/en-US/lint.ftl b/compiler/rustc_error_messages/locales/en-US/lint.ftl index 7f9918e4f12..6cc0cb49e1f 100644 --- a/compiler/rustc_error_messages/locales/en-US/lint.ftl +++ b/compiler/rustc_error_messages/locales/en-US/lint.ftl @@ -51,7 +51,7 @@ lint_non_existant_doc_keyword = found non-existing keyword `{$keyword}` used in .help = only existing keywords are allowed in core/std lint_diag_out_of_impl = - diagnostics should only be created in `SessionDiagnostic`/`AddSubdiagnostic` impls + diagnostics should only be created in `IntoDiagnostic`/`AddSubdiagnostic` impls lint_untranslatable_diag = diagnostics should be created using translatable messages diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs index 6dfb6b11b16..8a56068fcc7 100644 --- a/compiler/rustc_errors/src/diagnostic.rs +++ b/compiler/rustc_errors/src/diagnostic.rs @@ -35,7 +35,7 @@ pub enum DiagnosticArgValue<'source> { Number(usize), } -/// Converts a value of a type into a `DiagnosticArg` (typically a field of a `SessionDiagnostic` +/// Converts a value of a type into a `DiagnosticArg` (typically a field of an `IntoDiagnostic` /// struct). Implemented as a custom trait rather than `From` so that it is implemented on the type /// being converted rather than on `DiagnosticArgValue`, which enables types from other `rustc_*` /// crates to implement this. diff --git a/compiler/rustc_errors/src/diagnostic_builder.rs b/compiler/rustc_errors/src/diagnostic_builder.rs index 71e21373d0d..b646dd662cb 100644 --- a/compiler/rustc_errors/src/diagnostic_builder.rs +++ b/compiler/rustc_errors/src/diagnostic_builder.rs @@ -14,9 +14,10 @@ use std::ops::{Deref, DerefMut}; use std::thread::panicking; /// Trait implemented by error types. This should not be implemented manually. Instead, use -/// `#[derive(SessionDiagnostic)]` -- see [rustc_macros::SessionDiagnostic]. -#[rustc_diagnostic_item = "SessionDiagnostic"] -pub trait SessionDiagnostic<'a, T: EmissionGuarantee = ErrorGuaranteed> { +/// `#[derive(DiagnosticHandler)]` -- see [rustc_macros::DiagnosticHandler]. +#[cfg_attr(bootstrap, rustc_diagnostic_item = "SessionDiagnostic")] +#[cfg_attr(not(bootstrap), rustc_diagnostic_item = "DiagnosticHandler")] +pub trait IntoDiagnostic<'a, T: EmissionGuarantee = ErrorGuaranteed> { /// Write out as a diagnostic out of `Handler`. #[must_use] fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, T>; diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs index 3549d3c4999..aed52bce9aa 100644 --- a/compiler/rustc_errors/src/lib.rs +++ b/compiler/rustc_errors/src/lib.rs @@ -60,7 +60,7 @@ mod snippet; mod styled_buffer; pub mod translation; -pub use diagnostic_builder::SessionDiagnostic; +pub use diagnostic_builder::IntoDiagnostic; pub use snippet::Style; pub type PResult<'a, T> = Result>; @@ -647,6 +647,8 @@ impl Handler { /// Construct a builder with the `msg` at the level appropriate for the specific `EmissionGuarantee`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_diagnostic( &self, msg: impl Into, @@ -660,6 +662,8 @@ impl Handler { /// * `can_emit_warnings` is `true` /// * `is_force_warn` was set in `DiagnosticId::Lint` #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_warn( &self, span: impl Into, @@ -676,6 +680,8 @@ impl Handler { /// Attempting to `.emit()` the builder will only emit if either: /// * `can_emit_warnings` is `true` /// * `is_force_warn` was set in `DiagnosticId::Lint` + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_warn_with_expectation( &self, span: impl Into, @@ -689,6 +695,8 @@ impl Handler { /// Construct a builder at the `Allow` level at the given `span` and with the `msg`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_allow( &self, span: impl Into, @@ -702,6 +710,8 @@ impl Handler { /// Construct a builder at the `Warning` level at the given `span` and with the `msg`. /// Also include a code. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_warn_with_code( &self, span: impl Into, @@ -719,6 +729,8 @@ impl Handler { /// * `can_emit_warnings` is `true` /// * `is_force_warn` was set in `DiagnosticId::Lint` #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_warn(&self, msg: impl Into) -> DiagnosticBuilder<'_, ()> { DiagnosticBuilder::new(self, Level::Warning(None), msg) } @@ -729,6 +741,8 @@ impl Handler { /// Attempting to `.emit()` the builder will only emit if either: /// * `can_emit_warnings` is `true` /// * `is_force_warn` was set in `DiagnosticId::Lint` + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_warn_with_expectation( &self, msg: impl Into, @@ -739,12 +753,16 @@ impl Handler { /// Construct a builder at the `Allow` level with the `msg`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_allow(&self, msg: impl Into) -> DiagnosticBuilder<'_, ()> { DiagnosticBuilder::new(self, Level::Allow, msg) } /// Construct a builder at the `Expect` level with the `msg`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_expect( &self, msg: impl Into, @@ -755,6 +773,8 @@ impl Handler { /// Construct a builder at the `Error` level at the given `span` and with the `msg`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_err( &self, span: impl Into, @@ -767,6 +787,8 @@ impl Handler { /// Construct a builder at the `Error` level at the given `span`, with the `msg`, and `code`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_err_with_code( &self, span: impl Into, @@ -781,6 +803,8 @@ impl Handler { /// Construct a builder at the `Error` level with the `msg`. // FIXME: This method should be removed (every error should have an associated error code). #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_err( &self, msg: impl Into, @@ -790,12 +814,16 @@ impl Handler { /// This should only be used by `rustc_middle::lint::struct_lint_level`. Do not use it for hard errors. #[doc(hidden)] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_err_lint(&self, msg: impl Into) -> DiagnosticBuilder<'_, ()> { DiagnosticBuilder::new(self, Level::Error { lint: true }, msg) } /// Construct a builder at the `Error` level with the `msg` and the `code`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_err_with_code( &self, msg: impl Into, @@ -808,6 +836,8 @@ impl Handler { /// Construct a builder at the `Warn` level with the `msg` and the `code`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_warn_with_code( &self, msg: impl Into, @@ -820,6 +850,8 @@ impl Handler { /// Construct a builder at the `Fatal` level at the given `span` and with the `msg`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_fatal( &self, span: impl Into, @@ -832,6 +864,8 @@ impl Handler { /// Construct a builder at the `Fatal` level at the given `span`, with the `msg`, and `code`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_fatal_with_code( &self, span: impl Into, @@ -845,18 +879,24 @@ impl Handler { /// Construct a builder at the `Error` level with the `msg`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_fatal(&self, msg: impl Into) -> DiagnosticBuilder<'_, !> { DiagnosticBuilder::new_fatal(self, msg) } /// Construct a builder at the `Help` level with the `msg`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_help(&self, msg: impl Into) -> DiagnosticBuilder<'_, ()> { DiagnosticBuilder::new(self, Level::Help, msg) } /// Construct a builder at the `Note` level with the `msg`. #[rustc_lint_diagnostics] + #[allow(rustc::diagnostic_outside_of_impl)] + #[allow(rustc::untranslatable_diagnostic)] pub fn struct_note_without_error( &self, msg: impl Into, @@ -1029,6 +1069,39 @@ impl Handler { self.inner.borrow_mut().emit_diagnostic(diagnostic) } + pub fn emit_err<'a>(&'a self, err: impl IntoDiagnostic<'a>) -> ErrorGuaranteed { + self.create_err(err).emit() + } + + pub fn create_err<'a>( + &'a self, + err: impl IntoDiagnostic<'a>, + ) -> DiagnosticBuilder<'a, ErrorGuaranteed> { + err.into_diagnostic(self) + } + + pub fn create_warning<'a>( + &'a self, + warning: impl IntoDiagnostic<'a, ()>, + ) -> DiagnosticBuilder<'a, ()> { + warning.into_diagnostic(self) + } + + pub fn emit_warning<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) { + self.create_warning(warning).emit() + } + + pub fn create_fatal<'a>( + &'a self, + fatal: impl IntoDiagnostic<'a, !>, + ) -> DiagnosticBuilder<'a, !> { + fatal.into_diagnostic(self) + } + + pub fn emit_fatal<'a>(&'a self, fatal: impl IntoDiagnostic<'a, !>) -> ! { + self.create_fatal(fatal).emit() + } + fn emit_diag_at_span( &self, mut diag: Diagnostic, diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs index 11598ea0fff..ca429b6adc1 100644 --- a/compiler/rustc_expand/src/base.rs +++ b/compiler/rustc_expand/src/base.rs @@ -11,7 +11,7 @@ use rustc_attr::{self as attr, Deprecation, Stability}; use rustc_data_structures::fx::{FxHashSet, FxIndexMap}; use rustc_data_structures::sync::{self, Lrc}; use rustc_errors::{ - Applicability, DiagnosticBuilder, ErrorGuaranteed, MultiSpan, PResult, SessionDiagnostic, + Applicability, DiagnosticBuilder, IntoDiagnostic, ErrorGuaranteed, MultiSpan, PResult, }; use rustc_lint_defs::builtin::PROC_MACRO_BACK_COMPAT; use rustc_lint_defs::{BufferedEarlyLint, BuiltinLintDiagnostics}; @@ -1111,12 +1111,12 @@ impl<'a> ExtCtxt<'a> { pub fn create_err( &self, - err: impl SessionDiagnostic<'a>, + err: impl IntoDiagnostic<'a>, ) -> DiagnosticBuilder<'a, ErrorGuaranteed> { self.sess.create_err(err) } - pub fn emit_err(&self, err: impl SessionDiagnostic<'a>) -> ErrorGuaranteed { + pub fn emit_err(&self, err: impl IntoDiagnostic<'a>) -> ErrorGuaranteed { self.sess.emit_err(err) } diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs index 0feae0debd2..7cbdad3cd95 100644 --- a/compiler/rustc_expand/src/errors.rs +++ b/compiler/rustc_expand/src/errors.rs @@ -1,29 +1,29 @@ -use rustc_macros::SessionDiagnostic; +use rustc_macros::DiagnosticHandler; use rustc_span::symbol::MacroRulesNormalizedIdent; use rustc_span::Span; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(expand::expr_repeat_no_syntax_vars)] pub(crate) struct NoSyntaxVarsExprRepeat { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(expand::must_repeat_once)] pub(crate) struct MustRepeatOnce { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(expand::count_repetition_misplaced)] pub(crate) struct CountRepetitionMisplaced { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(expand::meta_var_expr_unrecognized_var)] pub(crate) struct MetaVarExprUnrecognizedVar { #[primary_span] @@ -31,7 +31,7 @@ pub(crate) struct MetaVarExprUnrecognizedVar { pub key: MacroRulesNormalizedIdent, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(expand::var_still_repeating)] pub(crate) struct VarStillRepeating { #[primary_span] @@ -39,7 +39,7 @@ pub(crate) struct VarStillRepeating { pub ident: MacroRulesNormalizedIdent, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(expand::meta_var_dif_seq_matchers)] pub(crate) struct MetaVarsDifSeqMatchers { #[primary_span] diff --git a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs index dccd3f3a1cc..baa97d72a4b 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs @@ -4,7 +4,7 @@ use crate::errors::{ }; use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; use crate::infer::InferCtxt; -use rustc_errors::SessionDiagnostic; +use rustc_errors::IntoDiagnostic; use rustc_errors::{DiagnosticBuilder, ErrorGuaranteed, IntoDiagnosticArg}; use rustc_hir as hir; use rustc_hir::def::Res; diff --git a/compiler/rustc_interface/src/errors.rs b/compiler/rustc_interface/src/errors.rs index 6a497aed4ab..dc975099fc7 100644 --- a/compiler/rustc_interface/src/errors.rs +++ b/compiler/rustc_interface/src/errors.rs @@ -1,10 +1,10 @@ -use rustc_macros::SessionDiagnostic; +use rustc_macros::DiagnosticHandler; use rustc_span::{Span, Symbol}; use std::io; use std::path::Path; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::ferris_identifier)] pub struct FerrisIdentifier { #[primary_span] @@ -13,7 +13,7 @@ pub struct FerrisIdentifier { pub first_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::emoji_identifier)] pub struct EmojiIdentifier { #[primary_span] @@ -21,67 +21,67 @@ pub struct EmojiIdentifier { pub ident: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::mixed_bin_crate)] pub struct MixedBinCrate; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::mixed_proc_macro_crate)] pub struct MixedProcMacroCrate; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::proc_macro_doc_without_arg)] pub struct ProcMacroDocWithoutArg; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::error_writing_dependencies)] pub struct ErrorWritingDependencies<'a> { pub path: &'a Path, pub error: io::Error, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::input_file_would_be_overwritten)] pub struct InputFileWouldBeOverWritten<'a> { pub path: &'a Path, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::generated_file_conflicts_with_directory)] pub struct GeneratedFileConflictsWithDirectory<'a> { pub input_path: &'a Path, pub dir_path: &'a Path, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::temps_dir_error)] pub struct TempsDirError; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::out_dir_error)] pub struct OutDirError; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::cant_emit_mir)] pub struct CantEmitMIR { pub error: io::Error, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::rustc_error_fatal)] pub struct RustcErrorFatal { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::rustc_error_unexpected_annotation)] pub struct RustcErrorUnexpectedAnnotation { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(interface::failed_writing_file)] pub struct FailedWritingFile<'a> { pub path: &'a Path, diff --git a/compiler/rustc_lint/src/errors.rs b/compiler/rustc_lint/src/errors.rs index ac98948189b..261570acb7b 100644 --- a/compiler/rustc_lint/src/errors.rs +++ b/compiler/rustc_lint/src/errors.rs @@ -1,9 +1,9 @@ -use rustc_errors::{fluent, AddSubdiagnostic, ErrorGuaranteed, Handler, SessionDiagnostic}; -use rustc_macros::{SessionDiagnostic, SessionSubdiagnostic}; +use rustc_errors::{fluent, AddSubdiagnostic, IntoDiagnostic, ErrorGuaranteed, Handler}; +use rustc_macros::{DiagnosticHandler, SessionSubdiagnostic}; use rustc_session::lint::Level; use rustc_span::{Span, Symbol}; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(lint::overruled_attribute, code = "E0453")] pub struct OverruledAttribute { #[primary_span] @@ -42,7 +42,7 @@ impl AddSubdiagnostic for OverruledAttributeSub { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(lint::malformed_attribute, code = "E0452")] pub struct MalformedAttribute { #[primary_span] @@ -61,7 +61,7 @@ pub enum MalformedAttributeSub { ReasonMustComeLast(#[primary_span] Span), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(lint::unknown_tool_in_scoped_lint, code = "E0710")] pub struct UnknownToolInScopedLint { #[primary_span] @@ -72,7 +72,7 @@ pub struct UnknownToolInScopedLint { pub is_nightly_build: Option<()>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(lint::builtin_ellipsis_inclusive_range_patterns, code = "E0783")] pub struct BuiltinEllpisisInclusiveRangePatterns { #[primary_span] @@ -107,7 +107,7 @@ impl AddSubdiagnostic for RequestedLevel { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(lint::unsupported_group, code = "E0602")] pub struct UnsupportedGroup { pub lint_group: String, @@ -119,7 +119,7 @@ pub struct CheckNameUnknown { pub sub: RequestedLevel, } -impl SessionDiagnostic<'_> for CheckNameUnknown { +impl IntoDiagnostic<'_> for CheckNameUnknown { fn into_diagnostic( self, handler: &Handler, @@ -136,7 +136,7 @@ impl SessionDiagnostic<'_> for CheckNameUnknown { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(lint::check_name_unknown_tool, code = "E0602")] pub struct CheckNameUnknownTool { pub tool_name: Symbol, @@ -144,7 +144,7 @@ pub struct CheckNameUnknownTool { pub sub: RequestedLevel, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(lint::check_name_warning)] pub struct CheckNameWarning { pub msg: String, @@ -152,7 +152,7 @@ pub struct CheckNameWarning { pub sub: RequestedLevel, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(lint::check_name_deprecated)] pub struct CheckNameDeprecated { pub lint_name: String, diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs index dd1fc5916db..dec75c9d380 100644 --- a/compiler/rustc_lint/src/internal.rs +++ b/compiler/rustc_lint/src/internal.rs @@ -372,7 +372,7 @@ declare_tool_lint! { declare_tool_lint! { pub rustc::DIAGNOSTIC_OUTSIDE_OF_IMPL, Allow, - "prevent creation of diagnostics outside of `SessionDiagnostic`/`AddSubdiagnostic` impls", + "prevent creation of diagnostics outside of `DiagnosticHandler`/`AddSubdiagnostic` impls", report_in_external_macro: true } @@ -404,7 +404,7 @@ impl LateLintPass<'_> for Diagnostics { let Impl { of_trait: Some(of_trait), .. } = impl_ && let Some(def_id) = of_trait.trait_def_id() && let Some(name) = cx.tcx.get_diagnostic_name(def_id) && - matches!(name, sym::SessionDiagnostic | sym::AddSubdiagnostic | sym::DecorateLint) + matches!(name, sym::DiagnosticHandler | sym::AddSubdiagnostic | sym::DecorateLint) { found_impl = true; break; diff --git a/compiler/rustc_macros/src/diagnostics/diagnostic.rs b/compiler/rustc_macros/src/diagnostics/diagnostic.rs index 891b6a118de..c5b5edab816 100644 --- a/compiler/rustc_macros/src/diagnostics/diagnostic.rs +++ b/compiler/rustc_macros/src/diagnostics/diagnostic.rs @@ -11,27 +11,27 @@ use synstructure::Structure; /// The central struct for constructing the `into_diagnostic` method from an annotated struct. pub(crate) struct SessionDiagnosticDerive<'a> { structure: Structure<'a>, - sess: syn::Ident, + handler: syn::Ident, builder: DiagnosticDeriveBuilder, } impl<'a> SessionDiagnosticDerive<'a> { - pub(crate) fn new(diag: syn::Ident, sess: syn::Ident, structure: Structure<'a>) -> Self { + pub(crate) fn new(diag: syn::Ident, handler: syn::Ident, structure: Structure<'a>) -> Self { Self { builder: DiagnosticDeriveBuilder { diag, fields: build_field_mapping(&structure), - kind: DiagnosticDeriveKind::SessionDiagnostic, + kind: DiagnosticDeriveKind::DiagnosticHandler, code: None, slug: None, }, - sess, + handler, structure, } } pub(crate) fn into_tokens(self) -> TokenStream { - let SessionDiagnosticDerive { mut structure, sess, mut builder } = self; + let SessionDiagnosticDerive { mut structure, handler, mut builder } = self; let ast = structure.ast(); let implementation = { @@ -53,7 +53,7 @@ impl<'a> SessionDiagnosticDerive<'a> { } Some(slug) => { quote! { - let mut #diag = #sess.struct_diagnostic(rustc_errors::fluent::#slug); + let mut #diag = #handler.struct_diagnostic(rustc_errors::fluent::#slug); } } }; @@ -72,7 +72,7 @@ impl<'a> SessionDiagnosticDerive<'a> { } else { span_err( ast.span().unwrap(), - "`#[derive(SessionDiagnostic)]` can only be used on structs", + "`#[derive(DiagnosticHandler)]` can only be used on structs", ) .emit(); @@ -81,15 +81,15 @@ impl<'a> SessionDiagnosticDerive<'a> { }; structure.gen_impl(quote! { - gen impl<'__session_diagnostic_sess, G> - rustc_errors::SessionDiagnostic<'__session_diagnostic_sess, G> + gen impl<'__diagnostic_handler_sess, G> + rustc_errors::IntoDiagnostic<'__diagnostic_handler_sess, G> for @Self where G: rustc_errors::EmissionGuarantee { fn into_diagnostic( self, - #sess: &'__session_diagnostic_sess rustc_errors::Handler - ) -> rustc_errors::DiagnosticBuilder<'__session_diagnostic_sess, G> { + #handler: &'__diagnostic_handler_sess rustc_errors::Handler + ) -> rustc_errors::DiagnosticBuilder<'__diagnostic_handler_sess, G> { use rustc_errors::IntoDiagnosticArg; #implementation } diff --git a/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs b/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs index 2a4fe48a8ac..4af3fd23624 100644 --- a/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs +++ b/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs @@ -21,12 +21,12 @@ use synstructure::{BindingInfo, Structure}; /// What kind of diagnostic is being derived - a fatal/error/warning or a lint? #[derive(Copy, Clone, PartialEq, Eq)] pub(crate) enum DiagnosticDeriveKind { - SessionDiagnostic, + DiagnosticHandler, LintDiagnostic, } /// Tracks persistent information required for building up individual calls to diagnostic methods -/// for generated diagnostic derives - both `SessionDiagnostic` for fatal/errors/warnings and +/// for generated diagnostic derives - both `DiagnosticHandler` for fatal/errors/warnings and /// `LintDiagnostic` for lints. pub(crate) struct DiagnosticDeriveBuilder { /// The identifier to use for the generated `DiagnosticBuilder` instance. @@ -333,7 +333,7 @@ impl DiagnosticDeriveBuilder { } "primary_span" => { match self.kind { - DiagnosticDeriveKind::SessionDiagnostic => { + DiagnosticDeriveKind::DiagnosticHandler => { report_error_if_not_applied_to_span(attr, &info)?; Ok(quote! { diff --git a/compiler/rustc_macros/src/diagnostics/mod.rs b/compiler/rustc_macros/src/diagnostics/mod.rs index 2ff21e18ff8..162089c881e 100644 --- a/compiler/rustc_macros/src/diagnostics/mod.rs +++ b/compiler/rustc_macros/src/diagnostics/mod.rs @@ -12,7 +12,7 @@ use quote::format_ident; use subdiagnostic::SessionSubdiagnosticDerive; use synstructure::Structure; -/// Implements `#[derive(SessionDiagnostic)]`, which allows for errors to be specified as a struct, +/// Implements `#[derive(DiagnosticHandler)]`, which allows for errors to be specified as a struct, /// independent from the actual diagnostics emitting code. /// /// ```ignore (rust) @@ -22,7 +22,7 @@ use synstructure::Structure; /// # use rustc_span::{symbol::Ident, Span}; /// # extern crate rust_middle; /// # use rustc_middle::ty::Ty; -/// #[derive(SessionDiagnostic)] +/// #[derive(DiagnosticHandler)] /// #[diag(borrowck::move_out_of_borrow, code = "E0505")] /// pub struct MoveOutOfBorrowError<'tcx> { /// pub name: Ident, @@ -56,10 +56,10 @@ use synstructure::Structure; /// }); /// ``` /// -/// See rustc dev guide for more examples on using the `#[derive(SessionDiagnostic)]`: +/// See rustc dev guide for more examples on using the `#[derive(DiagnosticHandler)]`: /// pub fn session_diagnostic_derive(s: Structure<'_>) -> TokenStream { - SessionDiagnosticDerive::new(format_ident!("diag"), format_ident!("sess"), s).into_tokens() + SessionDiagnosticDerive::new(format_ident!("diag"), format_ident!("handler"), s).into_tokens() } /// Implements `#[derive(LintDiagnostic)]`, which allows for lints to be specified as a struct, diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs index 2c027d754da..13305782ff1 100644 --- a/compiler/rustc_macros/src/lib.rs +++ b/compiler/rustc_macros/src/lib.rs @@ -127,7 +127,7 @@ decl_derive!([TypeFoldable, attributes(type_foldable)] => type_foldable::type_fo decl_derive!([TypeVisitable, attributes(type_visitable)] => type_visitable::type_visitable_derive); decl_derive!([Lift, attributes(lift)] => lift::lift_derive); decl_derive!( - [SessionDiagnostic, attributes( + [DiagnosticHandler, attributes( // struct attributes diag, help, diff --git a/compiler/rustc_metadata/src/errors.rs b/compiler/rustc_metadata/src/errors.rs index 8cbcadb625a..0a5973ca1aa 100644 --- a/compiler/rustc_metadata/src/errors.rs +++ b/compiler/rustc_metadata/src/errors.rs @@ -3,49 +3,49 @@ use std::{ path::{Path, PathBuf}, }; -use rustc_errors::{error_code, ErrorGuaranteed, SessionDiagnostic}; -use rustc_macros::SessionDiagnostic; +use rustc_errors::{error_code, IntoDiagnostic, ErrorGuaranteed}; +use rustc_macros::DiagnosticHandler; use rustc_session::config; use rustc_span::{sym, Span, Symbol}; use rustc_target::spec::{PanicStrategy, TargetTriple}; use crate::locator::CrateFlavor; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::rlib_required)] pub struct RlibRequired { pub crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::lib_required)] pub struct LibRequired<'a> { pub crate_name: Symbol, pub kind: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::crate_dep_multiple)] #[help] pub struct CrateDepMultiple { pub crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::two_panic_runtimes)] pub struct TwoPanicRuntimes { pub prev_name: Symbol, pub cur_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::bad_panic_strategy)] pub struct BadPanicStrategy { pub runtime: Symbol, pub strategy: PanicStrategy, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::required_panic_strategy)] pub struct RequiredPanicStrategy { pub crate_name: Symbol, @@ -53,7 +53,7 @@ pub struct RequiredPanicStrategy { pub desired_strategy: PanicStrategy, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::incompatible_panic_in_drop_strategy)] pub struct IncompatiblePanicInDropStrategy { pub crate_name: Symbol, @@ -61,56 +61,56 @@ pub struct IncompatiblePanicInDropStrategy { pub desired_strategy: PanicStrategy, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::multiple_names_in_link)] pub struct MultipleNamesInLink { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::multiple_kinds_in_link)] pub struct MultipleKindsInLink { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::link_name_form)] pub struct LinkNameForm { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::link_kind_form)] pub struct LinkKindForm { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::link_modifiers_form)] pub struct LinkModifiersForm { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::link_cfg_form)] pub struct LinkCfgForm { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::wasm_import_form)] pub struct WasmImportForm { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::empty_link_name, code = "E0454")] pub struct EmptyLinkName { #[primary_span] @@ -118,21 +118,21 @@ pub struct EmptyLinkName { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::link_framework_apple, code = "E0455")] pub struct LinkFrameworkApple { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::framework_only_windows, code = "E0455")] pub struct FrameworkOnlyWindows { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::unknown_link_kind, code = "E0458")] pub struct UnknownLinkKind<'a> { #[primary_span] @@ -141,49 +141,49 @@ pub struct UnknownLinkKind<'a> { pub kind: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::multiple_link_modifiers)] pub struct MultipleLinkModifiers { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::multiple_cfgs)] pub struct MultipleCfgs { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::link_cfg_single_predicate)] pub struct LinkCfgSinglePredicate { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::multiple_wasm_import)] pub struct MultipleWasmImport { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::unexpected_link_arg)] pub struct UnexpectedLinkArg { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::invalid_link_modifier)] pub struct InvalidLinkModifier { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::multiple_modifiers)] pub struct MultipleModifiers<'a> { #[primary_span] @@ -191,28 +191,28 @@ pub struct MultipleModifiers<'a> { pub modifier: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::bundle_needs_static)] pub struct BundleNeedsStatic { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::whole_archive_needs_static)] pub struct WholeArchiveNeedsStatic { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::as_needed_compatibility)] pub struct AsNeededCompatibility { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::unknown_link_modifier)] pub struct UnknownLinkModifier<'a> { #[primary_span] @@ -220,14 +220,14 @@ pub struct UnknownLinkModifier<'a> { pub modifier: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::incompatible_wasm_link)] pub struct IncompatibleWasmLink { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::link_requires_name, code = "E0459")] pub struct LinkRequiresName { #[primary_span] @@ -235,105 +235,105 @@ pub struct LinkRequiresName { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::raw_dylib_no_nul)] pub struct RawDylibNoNul { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::link_ordinal_raw_dylib)] pub struct LinkOrdinalRawDylib { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::lib_framework_apple)] pub struct LibFrameworkApple; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::empty_renaming_target)] pub struct EmptyRenamingTarget<'a> { pub lib_name: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::renaming_no_link)] pub struct RenamingNoLink<'a> { pub lib_name: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::multiple_renamings)] pub struct MultipleRenamings<'a> { pub lib_name: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::no_link_mod_override)] pub struct NoLinkModOverride { #[primary_span] pub span: Option, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::unsupported_abi_i686)] pub struct UnsupportedAbiI686 { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::unsupported_abi)] pub struct UnsupportedAbi { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::fail_create_file_encoder)] pub struct FailCreateFileEncoder { pub err: Error, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::fail_seek_file)] pub struct FailSeekFile { pub err: Error, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::fail_write_file)] pub struct FailWriteFile { pub err: Error, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::crate_not_panic_runtime)] pub struct CrateNotPanicRuntime { pub crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::no_panic_strategy)] pub struct NoPanicStrategy { pub crate_name: Symbol, pub strategy: PanicStrategy, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::profiler_builtins_needs_core)] pub struct ProfilerBuiltinsNeedsCore; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::not_profiler_runtime)] pub struct NotProfilerRuntime { pub crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::no_multiple_global_alloc)] pub struct NoMultipleGlobalAlloc { #[primary_span] @@ -343,18 +343,18 @@ pub struct NoMultipleGlobalAlloc { pub span1: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::conflicting_global_alloc)] pub struct ConflictingGlobalAlloc { pub crate_name: Symbol, pub other_crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::global_alloc_required)] pub struct GlobalAllocRequired; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::no_transitive_needs_dep)] pub struct NoTransitiveNeedsDep<'a> { pub crate_name: Symbol, @@ -362,7 +362,7 @@ pub struct NoTransitiveNeedsDep<'a> { pub deps_crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::failed_write_error)] pub struct FailedWriteError { pub filename: PathBuf, @@ -381,20 +381,20 @@ pub struct FailedCreateTempdir { pub err: Error, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::failed_create_file)] pub struct FailedCreateFile<'a> { pub filename: &'a Path, pub err: Error, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::failed_create_encoded_metadata)] pub struct FailedCreateEncodedMetadata { pub err: Error, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::non_ascii_name)] pub struct NonAsciiName { #[primary_span] @@ -402,7 +402,7 @@ pub struct NonAsciiName { pub crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::extern_location_not_exist)] pub struct ExternLocationNotExist<'a> { #[primary_span] @@ -411,7 +411,7 @@ pub struct ExternLocationNotExist<'a> { pub location: &'a Path, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::extern_location_not_file)] pub struct ExternLocationNotFile<'a> { #[primary_span] @@ -427,7 +427,7 @@ pub(crate) struct MultipleCandidates { pub candidates: Vec, } -impl SessionDiagnostic<'_> for MultipleCandidates { +impl IntoDiagnostic<'_> for MultipleCandidates { fn into_diagnostic( self, handler: &'_ rustc_errors::Handler, @@ -444,7 +444,7 @@ impl SessionDiagnostic<'_> for MultipleCandidates { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::multiple_matching_crates, code = "E0464")] #[note] pub struct MultipleMatchingCrates { @@ -454,7 +454,7 @@ pub struct MultipleMatchingCrates { pub candidates: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::symbol_conflicts_current, code = "E0519")] pub struct SymbolConflictsCurrent { #[primary_span] @@ -462,7 +462,7 @@ pub struct SymbolConflictsCurrent { pub crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::symbol_conflicts_others, code = "E0523")] pub struct SymbolConflictsOthers { #[primary_span] @@ -470,7 +470,7 @@ pub struct SymbolConflictsOthers { pub crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::stable_crate_id_collision)] pub struct StableCrateIdCollision { #[primary_span] @@ -479,7 +479,7 @@ pub struct StableCrateIdCollision { pub crate_name1: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::dl_error)] pub struct DlError { #[primary_span] @@ -487,7 +487,7 @@ pub struct DlError { pub err: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::newer_crate_version, code = "E0460")] #[note] #[note(metadata::found_crate_versions)] @@ -499,7 +499,7 @@ pub struct NewerCrateVersion { pub found_crates: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::no_crate_with_triple, code = "E0461")] #[note(metadata::found_crate_versions)] pub struct NoCrateWithTriple<'a> { @@ -511,7 +511,7 @@ pub struct NoCrateWithTriple<'a> { pub found_crates: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::found_staticlib, code = "E0462")] #[note(metadata::found_crate_versions)] #[help] @@ -523,7 +523,7 @@ pub struct FoundStaticlib { pub found_crates: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::incompatible_rustc, code = "E0514")] #[note(metadata::found_crate_versions)] #[help] @@ -543,7 +543,7 @@ pub struct InvalidMetadataFiles { pub crate_rejections: Vec, } -impl SessionDiagnostic<'_> for InvalidMetadataFiles { +impl IntoDiagnostic<'_> for InvalidMetadataFiles { fn into_diagnostic( self, handler: &'_ rustc_errors::Handler, @@ -571,7 +571,7 @@ pub struct CannotFindCrate { pub locator_triple: TargetTriple, } -impl SessionDiagnostic<'_> for CannotFindCrate { +impl IntoDiagnostic<'_> for CannotFindCrate { fn into_diagnostic( self, handler: &'_ rustc_errors::Handler, @@ -617,7 +617,7 @@ impl SessionDiagnostic<'_> for CannotFindCrate { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::no_dylib_plugin, code = "E0457")] pub struct NoDylibPlugin { #[primary_span] @@ -625,7 +625,7 @@ pub struct NoDylibPlugin { pub crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::crate_location_unknown_type)] pub struct CrateLocationUnknownType<'a> { #[primary_span] @@ -633,7 +633,7 @@ pub struct CrateLocationUnknownType<'a> { pub path: &'a Path, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::lib_filename_form)] pub struct LibFilenameForm<'a> { #[primary_span] @@ -642,28 +642,28 @@ pub struct LibFilenameForm<'a> { pub dll_suffix: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::multiple_import_name_type)] pub struct MultipleImportNameType { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::import_name_type_form)] pub struct ImportNameTypeForm { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::import_name_type_x86)] pub struct ImportNameTypeX86 { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::unknown_import_name_type)] pub struct UnknownImportNameType<'a> { #[primary_span] @@ -671,7 +671,7 @@ pub struct UnknownImportNameType<'a> { pub import_name_type: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(metadata::import_name_type_raw)] pub struct ImportNameTypeRaw { #[primary_span] diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs index 18b31a75bcc..effda9c0557 100644 --- a/compiler/rustc_middle/src/error.rs +++ b/compiler/rustc_middle/src/error.rs @@ -1,9 +1,9 @@ -use rustc_macros::SessionDiagnostic; +use rustc_macros::DiagnosticHandler; use rustc_span::Span; use crate::ty::Ty; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(middle::drop_check_overflow, code = "E0320")] #[note] pub struct DropCheckOverflow<'tcx> { @@ -13,7 +13,7 @@ pub struct DropCheckOverflow<'tcx> { pub overflow_ty: Ty<'tcx>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(middle::opaque_hidden_type_mismatch)] pub struct OpaqueHiddenTypeMismatch<'tcx> { pub self_ty: Ty<'tcx>, @@ -39,7 +39,7 @@ pub enum TypeMismatchReason { }, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(middle::limit_invalid)] pub struct LimitInvalid<'a> { #[primary_span] diff --git a/compiler/rustc_mir_dataflow/src/errors.rs b/compiler/rustc_mir_dataflow/src/errors.rs index cc14257876c..0d36abed2c0 100644 --- a/compiler/rustc_mir_dataflow/src/errors.rs +++ b/compiler/rustc_mir_dataflow/src/errors.rs @@ -1,21 +1,21 @@ -use rustc_macros::SessionDiagnostic; +use rustc_macros::DiagnosticHandler; use rustc_span::{Span, Symbol}; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(mir_dataflow::path_must_end_in_filename)] pub(crate) struct PathMustEndInFilename { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(mir_dataflow::unknown_formatter)] pub(crate) struct UnknownFormatter { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(mir_dataflow::duplicate_values_for)] pub(crate) struct DuplicateValuesFor { #[primary_span] @@ -23,7 +23,7 @@ pub(crate) struct DuplicateValuesFor { pub name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(mir_dataflow::requires_an_argument)] pub(crate) struct RequiresAnArgument { #[primary_span] @@ -31,39 +31,39 @@ pub(crate) struct RequiresAnArgument { pub name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(mir_dataflow::stop_after_dataflow_ended_compilation)] pub(crate) struct StopAfterDataFlowEndedCompilation; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(mir_dataflow::peek_must_be_place_or_ref_place)] pub(crate) struct PeekMustBePlaceOrRefPlace { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(mir_dataflow::peek_must_be_not_temporary)] pub(crate) struct PeekMustBeNotTemporary { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(mir_dataflow::peek_bit_not_set)] pub(crate) struct PeekBitNotSet { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(mir_dataflow::peek_argument_not_a_local)] pub(crate) struct PeekArgumentNotALocal { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(mir_dataflow::peek_argument_untracked)] pub(crate) struct PeekArgumentUntracked { #[primary_span] diff --git a/compiler/rustc_monomorphize/src/errors.rs b/compiler/rustc_monomorphize/src/errors.rs index 883380dca08..150a702dc24 100644 --- a/compiler/rustc_monomorphize/src/errors.rs +++ b/compiler/rustc_monomorphize/src/errors.rs @@ -1,11 +1,11 @@ use std::path::PathBuf; +use rustc_errors::IntoDiagnostic; use rustc_errors::ErrorGuaranteed; -use rustc_errors::SessionDiagnostic; -use rustc_macros::{LintDiagnostic, SessionDiagnostic}; +use rustc_macros::{DiagnosticHandler, LintDiagnostic}; use rustc_span::Span; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(monomorphize::recursion_limit)] pub struct RecursionLimit { #[primary_span] @@ -19,7 +19,7 @@ pub struct RecursionLimit { pub path: PathBuf, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(monomorphize::type_length_limit)] #[help(monomorphize::consider_type_length_limit)] pub struct TypeLengthLimit { @@ -32,7 +32,7 @@ pub struct TypeLengthLimit { pub type_length: usize, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(monomorphize::requires_lang_item)] pub struct RequiresLangItem { pub lang_item: String, @@ -44,7 +44,7 @@ pub struct UnusedGenericParams { pub param_names: Vec, } -impl SessionDiagnostic<'_> for UnusedGenericParams { +impl IntoDiagnostic<'_> for UnusedGenericParams { fn into_diagnostic( self, handler: &'_ rustc_errors::Handler, @@ -72,11 +72,11 @@ pub struct LargeAssignmentsLint { pub limit: u64, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(monomorphize::unknown_partition_strategy)] pub struct UnknownPartitionStrategy; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(monomorphize::symbol_already_defined)] pub struct SymbolAlreadyDefined { #[primary_span] diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs index a65f523a0f4..02148193cf0 100644 --- a/compiler/rustc_parse/src/parser/diagnostics.rs +++ b/compiler/rustc_parse/src/parser/diagnostics.rs @@ -20,7 +20,7 @@ use rustc_errors::{ fluent, Applicability, DiagnosticBuilder, DiagnosticMessage, Handler, MultiSpan, PResult, }; use rustc_errors::{pluralize, struct_span_err, Diagnostic, ErrorGuaranteed}; -use rustc_macros::{SessionDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{DiagnosticHandler, SessionSubdiagnostic}; use rustc_span::source_map::Spanned; use rustc_span::symbol::{kw, sym, Ident}; use rustc_span::{Span, SpanSnippetError, DUMMY_SP}; @@ -242,7 +242,7 @@ impl MultiSugg { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::maybe_report_ambiguous_plus)] struct AmbiguousPlus { pub sum_ty: String, @@ -251,7 +251,7 @@ struct AmbiguousPlus { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::maybe_recover_from_bad_type_plus, code = "E0178")] struct BadTypePlus { pub ty: String, @@ -285,7 +285,7 @@ pub enum BadTypePlusSub { }, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::maybe_recover_from_bad_qpath_stage_2)] struct BadQPathStage2 { #[primary_span] @@ -294,7 +294,7 @@ struct BadQPathStage2 { ty: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::incorrect_semicolon)] struct IncorrectSemicolon<'a> { #[primary_span] @@ -305,7 +305,7 @@ struct IncorrectSemicolon<'a> { name: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::incorrect_use_of_await)] struct IncorrectUseOfAwait { #[primary_span] @@ -313,7 +313,7 @@ struct IncorrectUseOfAwait { span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::incorrect_use_of_await)] struct IncorrectAwait { #[primary_span] @@ -324,7 +324,7 @@ struct IncorrectAwait { question_mark: &'static str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::in_in_typo)] struct InInTypo { #[primary_span] @@ -333,7 +333,7 @@ struct InInTypo { sugg_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::invalid_variable_declaration)] pub struct InvalidVariableDeclaration { #[primary_span] @@ -362,7 +362,7 @@ pub enum InvalidVariableDeclarationSub { UseLetNotVar(#[primary_span] Span), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::invalid_comparison_operator)] pub(crate) struct InvalidComparisonOperator { #[primary_span] @@ -389,7 +389,7 @@ pub(crate) enum InvalidComparisonOperatorSub { Spaceship(#[primary_span] Span), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::invalid_logical_operator)] #[note] pub(crate) struct InvalidLogicalOperator { @@ -416,7 +416,7 @@ pub(crate) enum InvalidLogicalOperatorSub { Disjunction(#[primary_span] Span), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::tilde_is_not_unary_operator)] pub(crate) struct TildeAsUnaryOperator( #[primary_span] @@ -424,7 +424,7 @@ pub(crate) struct TildeAsUnaryOperator( pub Span, ); -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::unexpected_token_after_not)] pub(crate) struct NotAsNegationOperator { #[primary_span] @@ -458,7 +458,7 @@ pub enum NotAsNegationOperatorSub { SuggestNotLogical(#[primary_span] Span), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::malformed_loop_label)] pub(crate) struct MalformedLoopLabel { #[primary_span] @@ -467,7 +467,7 @@ pub(crate) struct MalformedLoopLabel { pub correct_label: Ident, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::lifetime_in_borrow_expression)] pub(crate) struct LifetimeInBorrowExpression { #[primary_span] @@ -477,15 +477,15 @@ pub(crate) struct LifetimeInBorrowExpression { pub lifetime_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::field_expression_with_generic)] pub(crate) struct FieldExpressionWithGeneric(#[primary_span] pub Span); -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::macro_invocation_with_qualified_path)] pub(crate) struct MacroInvocationWithQualifiedPath(#[primary_span] pub Span); -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::unexpected_token_after_label)] pub(crate) struct UnexpectedTokenAfterLabel( #[primary_span] @@ -493,7 +493,7 @@ pub(crate) struct UnexpectedTokenAfterLabel( pub Span, ); -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::require_colon_after_labeled_expression)] #[note] pub(crate) struct RequireColonAfterLabeledExpression { @@ -505,7 +505,7 @@ pub(crate) struct RequireColonAfterLabeledExpression { pub label_end: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::do_catch_syntax_removed)] #[note] pub(crate) struct DoCatchSyntaxRemoved { @@ -514,7 +514,7 @@ pub(crate) struct DoCatchSyntaxRemoved { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::float_literal_requires_integer_part)] pub(crate) struct FloatLiteralRequiresIntegerPart { #[primary_span] @@ -523,7 +523,7 @@ pub(crate) struct FloatLiteralRequiresIntegerPart { pub correct: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::invalid_int_literal_width)] #[help] pub(crate) struct InvalidIntLiteralWidth { @@ -532,7 +532,7 @@ pub(crate) struct InvalidIntLiteralWidth { pub width: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::invalid_num_literal_base_prefix)] #[note] pub(crate) struct InvalidNumLiteralBasePrefix { @@ -542,7 +542,7 @@ pub(crate) struct InvalidNumLiteralBasePrefix { pub fixed: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::invalid_num_literal_suffix)] #[help] pub(crate) struct InvalidNumLiteralSuffix { @@ -552,7 +552,7 @@ pub(crate) struct InvalidNumLiteralSuffix { pub suffix: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::invalid_float_literal_width)] #[help] pub(crate) struct InvalidFloatLiteralWidth { @@ -561,7 +561,7 @@ pub(crate) struct InvalidFloatLiteralWidth { pub width: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::invalid_float_literal_suffix)] #[help] pub(crate) struct InvalidFloatLiteralSuffix { @@ -571,14 +571,14 @@ pub(crate) struct InvalidFloatLiteralSuffix { pub suffix: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::int_literal_too_large)] pub(crate) struct IntLiteralTooLarge { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::missing_semicolon_before_array)] pub(crate) struct MissingSemicolonBeforeArray { #[primary_span] @@ -587,7 +587,7 @@ pub(crate) struct MissingSemicolonBeforeArray { pub semicolon: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::invalid_block_macro_segment)] pub(crate) struct InvalidBlockMacroSegment { #[primary_span] @@ -596,7 +596,7 @@ pub(crate) struct InvalidBlockMacroSegment { pub context: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::if_expression_missing_then_block)] pub(crate) struct IfExpressionMissingThenBlock { #[primary_span] @@ -613,7 +613,7 @@ pub(crate) enum IfExpressionMissingThenBlockSub { AddThenBlock(#[primary_span] Span), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::if_expression_missing_condition)] pub(crate) struct IfExpressionMissingCondition { #[primary_span] @@ -623,14 +623,14 @@ pub(crate) struct IfExpressionMissingCondition { pub block_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::expected_expression_found_let)] pub(crate) struct ExpectedExpressionFoundLet { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::expected_else_block)] pub(crate) struct ExpectedElseBlock { #[primary_span] @@ -642,7 +642,7 @@ pub(crate) struct ExpectedElseBlock { pub condition_start: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::outer_attribute_not_allowed_on_if_else)] pub(crate) struct OuterAttributeNotAllowedOnIfElse { #[primary_span] @@ -659,7 +659,7 @@ pub(crate) struct OuterAttributeNotAllowedOnIfElse { pub attributes: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::missing_in_in_for_loop)] pub(crate) struct MissingInInForLoop { #[primary_span] @@ -677,7 +677,7 @@ pub(crate) enum MissingInInForLoopSub { AddIn(#[primary_span] Span), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::missing_comma_after_match_arm)] pub(crate) struct MissingCommaAfterMatchArm { #[primary_span] @@ -685,7 +685,7 @@ pub(crate) struct MissingCommaAfterMatchArm { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::catch_after_try)] #[help] pub(crate) struct CatchAfterTry { @@ -693,7 +693,7 @@ pub(crate) struct CatchAfterTry { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::comma_after_base_struct)] #[note] pub(crate) struct CommaAfterBaseStruct { @@ -703,7 +703,7 @@ pub(crate) struct CommaAfterBaseStruct { pub comma: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::eq_field_init)] pub(crate) struct EqFieldInit { #[primary_span] @@ -712,7 +712,7 @@ pub(crate) struct EqFieldInit { pub eq: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::dotdotdot)] pub(crate) struct DotDotDot { #[primary_span] @@ -721,7 +721,7 @@ pub(crate) struct DotDotDot { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::left_arrow_operator)] pub(crate) struct LeftArrowOperator { #[primary_span] @@ -729,7 +729,7 @@ pub(crate) struct LeftArrowOperator { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::remove_let)] pub(crate) struct RemoveLet { #[primary_span] diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs index bb93f1cc260..ae77961b7bc 100644 --- a/compiler/rustc_parse/src/parser/expr.rs +++ b/compiler/rustc_parse/src/parser/expr.rs @@ -36,7 +36,7 @@ use rustc_ast::{AnonConst, BinOp, BinOpKind, FnDecl, FnRetTy, MacCall, Param, Ty use rustc_ast::{Arm, Async, BlockCheckMode, Expr, ExprKind, Label, Movability, RangeLimits}; use rustc_ast::{ClosureBinder, StmtKind}; use rustc_ast_pretty::pprust; -use rustc_errors::SessionDiagnostic; +use rustc_errors::IntoDiagnostic; use rustc_errors::{Applicability, Diagnostic, PResult}; use rustc_session::lint::builtin::BREAK_WITH_LABEL_AND_LOOP; use rustc_session::lint::BuiltinLintDiagnostics; diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs index 96cc8ae988c..ade5927be8e 100644 --- a/compiler/rustc_passes/src/errors.rs +++ b/compiler/rustc_passes/src/errors.rs @@ -1,5 +1,5 @@ use rustc_errors::{Applicability, MultiSpan}; -use rustc_macros::{LintDiagnostic, SessionDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{DiagnosticHandler, LintDiagnostic, SessionSubdiagnostic}; use rustc_span::{Span, Symbol}; #[derive(LintDiagnostic)] @@ -32,7 +32,7 @@ pub struct IgnoredInlineAttrFnProto; #[note] pub struct IgnoredInlineAttrConstants; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::inline_not_fn_or_closure, code = "E0518")] pub struct InlineNotFnOrClosure { #[primary_span] @@ -53,7 +53,7 @@ pub struct IgnoredNoCoveragePropagate; #[diag(passes::no_coverage_fn_defn)] pub struct IgnoredNoCoverageFnDefn; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::no_coverage_not_coverable, code = "E0788")] pub struct IgnoredNoCoverageNotCoverable { #[primary_span] @@ -62,7 +62,7 @@ pub struct IgnoredNoCoverageNotCoverable { pub defn_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::should_be_applied_to_fn)] pub struct AttrShouldBeAppliedToFn { #[primary_span] @@ -71,14 +71,14 @@ pub struct AttrShouldBeAppliedToFn { pub defn_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::naked_tracked_caller, code = "E0736")] pub struct NakedTrackedCaller { #[primary_span] pub attr_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::should_be_applied_to_fn, code = "E0739")] pub struct TrackedCallerWrongLocation { #[primary_span] @@ -87,7 +87,7 @@ pub struct TrackedCallerWrongLocation { pub defn_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::should_be_applied_to_struct_enum, code = "E0701")] pub struct NonExhaustiveWrongLocation { #[primary_span] @@ -96,7 +96,7 @@ pub struct NonExhaustiveWrongLocation { pub defn_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::should_be_applied_to_trait)] pub struct AttrShouldBeAppliedToTrait { #[primary_span] @@ -109,7 +109,7 @@ pub struct AttrShouldBeAppliedToTrait { #[diag(passes::target_feature_on_statement)] pub struct TargetFeatureOnStatement; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::should_be_applied_to_static)] pub struct AttrShouldBeAppliedToStatic { #[primary_span] @@ -118,7 +118,7 @@ pub struct AttrShouldBeAppliedToStatic { pub defn_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_expect_str)] pub struct DocExpectStr<'a> { #[primary_span] @@ -126,7 +126,7 @@ pub struct DocExpectStr<'a> { pub attr_name: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_alias_empty)] pub struct DocAliasEmpty<'a> { #[primary_span] @@ -134,7 +134,7 @@ pub struct DocAliasEmpty<'a> { pub attr_str: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_alias_bad_char)] pub struct DocAliasBadChar<'a> { #[primary_span] @@ -143,7 +143,7 @@ pub struct DocAliasBadChar<'a> { pub char_: char, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_alias_start_end)] pub struct DocAliasStartEnd<'a> { #[primary_span] @@ -151,7 +151,7 @@ pub struct DocAliasStartEnd<'a> { pub attr_str: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_alias_bad_location)] pub struct DocAliasBadLocation<'a> { #[primary_span] @@ -160,7 +160,7 @@ pub struct DocAliasBadLocation<'a> { pub location: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_alias_not_an_alias)] pub struct DocAliasNotAnAlias<'a> { #[primary_span] @@ -175,35 +175,35 @@ pub struct DocAliasDuplicated { pub first_defn: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_alias_not_string_literal)] pub struct DocAliasNotStringLiteral { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_alias_malformed)] pub struct DocAliasMalformed { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_keyword_empty_mod)] pub struct DocKeywordEmptyMod { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_keyword_not_mod)] pub struct DocKeywordNotMod { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_keyword_invalid_ident)] pub struct DocKeywordInvalidIdent { #[primary_span] @@ -211,21 +211,21 @@ pub struct DocKeywordInvalidIdent { pub doc_keyword: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_fake_variadic_not_valid)] pub struct DocFakeVariadicNotValid { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_keyword_only_impl)] pub struct DocKeywordOnlyImpl { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_inline_conflict)] #[help] pub struct DocKeywordConflict { @@ -243,7 +243,7 @@ pub struct DocInlineOnlyUse { pub item_span: Option, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::doc_attr_not_crate_level)] pub struct DocAttrNotCrateLevel<'a> { #[primary_span] @@ -295,7 +295,7 @@ pub struct DocTestUnknownInclude { #[diag(passes::doc_invalid)] pub struct DocInvalid; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::pass_by_value)] pub struct PassByValue { #[primary_span] @@ -304,7 +304,7 @@ pub struct PassByValue { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::allow_incoherent_impl)] pub struct AllowIncoherentImpl { #[primary_span] @@ -313,7 +313,7 @@ pub struct AllowIncoherentImpl { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::has_incoherent_inherent_impl)] pub struct HasIncoherentInherentImpl { #[primary_span] @@ -336,7 +336,7 @@ pub struct MustUseNoEffect { pub target: rustc_hir::Target, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::must_not_suspend)] pub struct MustNotSuspend { #[primary_span] @@ -372,7 +372,7 @@ pub struct LinkName<'a> { pub value: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::no_link)] pub struct NoLink { #[primary_span] @@ -381,7 +381,7 @@ pub struct NoLink { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::export_name)] pub struct ExportName { #[primary_span] @@ -390,7 +390,7 @@ pub struct ExportName { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_layout_scalar_valid_range_not_struct)] pub struct RustcLayoutScalarValidRangeNotStruct { #[primary_span] @@ -399,14 +399,14 @@ pub struct RustcLayoutScalarValidRangeNotStruct { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_layout_scalar_valid_range_arg)] pub struct RustcLayoutScalarValidRangeArg { #[primary_span] pub attr_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_legacy_const_generics_only)] pub struct RustcLegacyConstGenericsOnly { #[primary_span] @@ -415,7 +415,7 @@ pub struct RustcLegacyConstGenericsOnly { pub param_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_legacy_const_generics_index)] pub struct RustcLegacyConstGenericsIndex { #[primary_span] @@ -424,7 +424,7 @@ pub struct RustcLegacyConstGenericsIndex { pub generics_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_legacy_const_generics_index_exceed)] pub struct RustcLegacyConstGenericsIndexExceed { #[primary_span] @@ -433,14 +433,14 @@ pub struct RustcLegacyConstGenericsIndexExceed { pub arg_count: usize, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_legacy_const_generics_index_negative)] pub struct RustcLegacyConstGenericsIndexNegative { #[primary_span] pub invalid_args: Vec, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_dirty_clean)] pub struct RustcDirtyClean { #[primary_span] @@ -475,7 +475,7 @@ pub struct NoMangle { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::repr_ident, code = "E0565")] pub struct ReprIdent { #[primary_span] @@ -486,21 +486,21 @@ pub struct ReprIdent { #[diag(passes::repr_conflicting, code = "E0566")] pub struct ReprConflicting; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::used_static)] pub struct UsedStatic { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::used_compiler_linker)] pub struct UsedCompilerLinker { #[primary_span] pub spans: Vec, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::allow_internal_unstable)] pub struct AllowInternalUnstable { #[primary_span] @@ -509,14 +509,14 @@ pub struct AllowInternalUnstable { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::debug_visualizer_placement)] pub struct DebugVisualizerPlacement { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::debug_visualizer_invalid)] #[note(passes::note_1)] #[note(passes::note_2)] @@ -526,7 +526,7 @@ pub struct DebugVisualizerInvalid { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_allow_const_fn_unstable)] pub struct RustcAllowConstFnUnstable { #[primary_span] @@ -535,7 +535,7 @@ pub struct RustcAllowConstFnUnstable { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_std_internal_symbol)] pub struct RustcStdInternalSymbol { #[primary_span] @@ -544,21 +544,21 @@ pub struct RustcStdInternalSymbol { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::const_trait)] pub struct ConstTrait { #[primary_span] pub attr_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::link_ordinal)] pub struct LinkOrdinal { #[primary_span] pub attr_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::stability_promotable)] pub struct StabilityPromotable { #[primary_span] @@ -602,7 +602,7 @@ pub struct Unused { pub note: UnusedNote, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::non_exported_macro_invalid_attrs, code = "E0518")] pub struct NonExportedMacroInvalidAttrs { #[primary_span] @@ -621,7 +621,7 @@ pub struct UnusedDuplicate { pub warning: Option<()>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::unused_multiple)] pub struct UnusedMultiple { #[primary_span] @@ -632,7 +632,7 @@ pub struct UnusedMultiple { pub name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_lint_opt_ty)] pub struct RustcLintOptTy { #[primary_span] @@ -641,7 +641,7 @@ pub struct RustcLintOptTy { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(passes::rustc_lint_opt_deny_field_access)] pub struct RustcLintOptDenyFieldAccess { #[primary_span] diff --git a/compiler/rustc_plugin_impl/src/errors.rs b/compiler/rustc_plugin_impl/src/errors.rs index 2bdb6e4feca..0b2c09f9e1d 100644 --- a/compiler/rustc_plugin_impl/src/errors.rs +++ b/compiler/rustc_plugin_impl/src/errors.rs @@ -1,9 +1,9 @@ //! Errors emitted by plugin_impl -use rustc_macros::SessionDiagnostic; +use rustc_macros::DiagnosticHandler; use rustc_span::Span; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(plugin_impl::load_plugin_error)] pub struct LoadPluginError { #[primary_span] @@ -11,7 +11,7 @@ pub struct LoadPluginError { pub msg: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(plugin_impl::malformed_plugin_attribute, code = "E0498")] pub struct MalformedPluginAttribute { #[primary_span] diff --git a/compiler/rustc_privacy/src/errors.rs b/compiler/rustc_privacy/src/errors.rs index 705ad567aa7..56a2cb059b5 100644 --- a/compiler/rustc_privacy/src/errors.rs +++ b/compiler/rustc_privacy/src/errors.rs @@ -1,8 +1,8 @@ use rustc_errors::DiagnosticArgFromDisplay; -use rustc_macros::{LintDiagnostic, SessionDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{DiagnosticHandler, LintDiagnostic, SessionSubdiagnostic}; use rustc_span::{Span, Symbol}; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(privacy::field_is_private, code = "E0451")] pub struct FieldIsPrivate { #[primary_span] @@ -29,7 +29,7 @@ pub enum FieldIsPrivateLabel { }, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(privacy::item_is_private)] pub struct ItemIsPrivate<'a> { #[primary_span] @@ -39,7 +39,7 @@ pub struct ItemIsPrivate<'a> { pub descr: DiagnosticArgFromDisplay<'a>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(privacy::unnamed_item_is_private)] pub struct UnnamedItemIsPrivate { #[primary_span] @@ -48,7 +48,7 @@ pub struct UnnamedItemIsPrivate { } // Duplicate of `InPublicInterface` but with a different error code, shares the same slug. -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(privacy::in_public_interface, code = "E0445")] pub struct InPublicInterfaceTraits<'a> { #[primary_span] @@ -62,7 +62,7 @@ pub struct InPublicInterfaceTraits<'a> { } // Duplicate of `InPublicInterfaceTraits` but with a different error code, shares the same slug. -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(privacy::in_public_interface, code = "E0446")] pub struct InPublicInterface<'a> { #[primary_span] @@ -75,7 +75,7 @@ pub struct InPublicInterface<'a> { pub vis_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(privacy::report_effective_visibility)] pub struct ReportEffectiveVisibility { #[primary_span] diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs index bececca7585..97a74517f68 100644 --- a/compiler/rustc_query_system/src/error.rs +++ b/compiler/rustc_query_system/src/error.rs @@ -1,4 +1,4 @@ -use rustc_errors::AddSubdiagnostic; +use rustc_errors::AddToDiagnostic; use rustc_session::Limit; use rustc_span::{Span, Symbol}; @@ -7,7 +7,7 @@ pub struct CycleStack { pub desc: String, } -impl AddSubdiagnostic for CycleStack { +impl AddToDiagnostic for CycleStack { fn add_to_diagnostic(self, diag: &mut rustc_errors::Diagnostic) { diag.span_note(self.span, &format!("...which requires {}...", self.desc)); } @@ -46,7 +46,7 @@ pub struct CycleUsage { pub usage: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(query_system::cycle, code = "E0391")] pub struct Cycle { #[primary_span] @@ -62,11 +62,11 @@ pub struct Cycle { pub cycle_usage: Option, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(query_system::reentrant)] pub struct Reentrant; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(query_system::increment_compilation)] #[help] #[note(query_system::increment_compilation_note1)] @@ -76,7 +76,7 @@ pub struct IncrementCompilation { pub dep_node: String, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[help] #[diag(query_system::query_overflow)] pub struct QueryOverflow { @@ -88,7 +88,7 @@ pub struct QueryOverflow { pub crate_name: Symbol, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[note(query_system::layout_of_depth)] pub struct LayoutOfDepth { pub desc: String, diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs index 705305ff806..6d26c8f47f3 100644 --- a/compiler/rustc_query_system/src/query/job.rs +++ b/compiler/rustc_query_system/src/query/job.rs @@ -4,7 +4,7 @@ use crate::query::{QueryContext, QueryStackFrame}; use rustc_data_structures::fx::FxHashMap; use rustc_errors::{ - Diagnostic, DiagnosticBuilder, ErrorGuaranteed, Handler, Level, SessionDiagnostic, + Diagnostic, DiagnosticBuilder, IntoDiagnostic, ErrorGuaranteed, Handler, Level, }; use rustc_hir::def::DefKind; use rustc_session::Session; diff --git a/compiler/rustc_save_analysis/src/errors.rs b/compiler/rustc_save_analysis/src/errors.rs index f0ce41d02a6..0983ec2f6f7 100644 --- a/compiler/rustc_save_analysis/src/errors.rs +++ b/compiler/rustc_save_analysis/src/errors.rs @@ -1,8 +1,8 @@ -use rustc_macros::SessionDiagnostic; +use rustc_macros::DiagnosticHandler; use std::path::Path; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(save_analysis::could_not_open)] pub(crate) struct CouldNotOpen<'a> { pub file_name: &'a Path, diff --git a/compiler/rustc_session/src/errors.rs b/compiler/rustc_session/src/errors.rs index c6596ff2498..4cf46109895 100644 --- a/compiler/rustc_session/src/errors.rs +++ b/compiler/rustc_session/src/errors.rs @@ -8,7 +8,7 @@ use rustc_span::{Span, Symbol}; use rustc_target::abi::TargetDataLayoutErrors; use rustc_target::spec::{SplitDebuginfo, StackProtector, TargetTriple}; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(session::incorrect_cgu_reuse_type)] pub struct IncorrectCguReuseType<'a> { #[primary_span] @@ -19,14 +19,14 @@ pub struct IncorrectCguReuseType<'a> { pub at_least: u8, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(session::cgu_not_recorded)] pub struct CguNotRecorded<'a> { pub cgu_user_name: &'a str, pub cgu_name: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(session::feature_gate_error, code = "E0658")] pub struct FeatureGateError<'a> { #[primary_span] @@ -46,19 +46,19 @@ pub struct FeatureDiagnosticHelp { pub feature: Symbol, } -impl SessionDiagnostic<'_, !> for TargetDataLayoutErrors<'_> { - fn into_diagnostic(self, sess: &Handler) -> DiagnosticBuilder<'_, !> { +impl DiagnosticHandler<'_, !> for TargetDataLayoutErrors<'_> { + fn into_diagnostic(self, handler: &Handler) -> DiagnosticBuilder<'_, !> { let mut diag; match self { TargetDataLayoutErrors::InvalidAddressSpace { addr_space, err, cause } => { - diag = sess.struct_fatal(fluent::session::target_invalid_address_space); + diag = handler.struct_fatal(fluent::session::target_invalid_address_space); diag.set_arg("addr_space", addr_space); diag.set_arg("cause", cause); diag.set_arg("err", err); diag } TargetDataLayoutErrors::InvalidBits { kind, bit, cause, err } => { - diag = sess.struct_fatal(fluent::session::target_invalid_bits); + diag = handler.struct_fatal(fluent::session::target_invalid_bits); diag.set_arg("kind", kind); diag.set_arg("bit", bit); diag.set_arg("cause", cause); @@ -66,30 +66,30 @@ impl SessionDiagnostic<'_, !> for TargetDataLayoutErrors<'_> { diag } TargetDataLayoutErrors::MissingAlignment { cause } => { - diag = sess.struct_fatal(fluent::session::target_missing_alignment); + diag = handler.struct_fatal(fluent::session::target_missing_alignment); diag.set_arg("cause", cause); diag } TargetDataLayoutErrors::InvalidAlignment { cause, err } => { - diag = sess.struct_fatal(fluent::session::target_invalid_alignment); + diag = handler.struct_fatal(fluent::session::target_invalid_alignment); diag.set_arg("cause", cause); diag.set_arg("err", err); diag } TargetDataLayoutErrors::InconsistentTargetArchitecture { dl, target } => { - diag = sess.struct_fatal(fluent::session::target_inconsistent_architecture); + diag = handler.struct_fatal(fluent::session::target_inconsistent_architecture); diag.set_arg("dl", dl); diag.set_arg("target", target); diag } TargetDataLayoutErrors::InconsistentTargetPointerWidth { pointer_size, target } => { - diag = sess.struct_fatal(fluent::session::target_inconsistent_pointer_width); + diag = handler.struct_fatal(fluent::session::target_inconsistent_pointer_width); diag.set_arg("pointer_size", pointer_size); diag.set_arg("target", target); diag } TargetDataLayoutErrors::InvalidBitsSize { err } => { - diag = sess.struct_fatal(fluent::session::target_invalid_bits_size); + diag = handler.struct_fatal(fluent::session::target_invalid_bits_size); diag.set_arg("err", err); diag } diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs index 564629a6703..3189dcb08ad 100644 --- a/compiler/rustc_session/src/parse.rs +++ b/compiler/rustc_session/src/parse.rs @@ -11,8 +11,8 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet}; use rustc_data_structures::sync::{Lock, Lrc}; use rustc_errors::{emitter::SilentEmitter, ColorConfig, Handler}; use rustc_errors::{ - fallback_fluent_bundle, Applicability, Diagnostic, DiagnosticBuilder, DiagnosticId, - DiagnosticMessage, EmissionGuarantee, ErrorGuaranteed, MultiSpan, SessionDiagnostic, StashKey, + fallback_fluent_bundle, Applicability, Diagnostic, DiagnosticBuilder, IntoDiagnostic, + DiagnosticId, DiagnosticMessage, EmissionGuarantee, ErrorGuaranteed, MultiSpan, StashKey, }; use rustc_feature::{find_feature_issue, GateIssue, UnstableFeatures}; use rustc_span::edition::Edition; @@ -344,34 +344,34 @@ impl ParseSess { pub fn create_err<'a>( &'a self, - err: impl SessionDiagnostic<'a>, + err: impl IntoDiagnostic<'a>, ) -> DiagnosticBuilder<'a, ErrorGuaranteed> { err.into_diagnostic(&self.span_diagnostic) } - pub fn emit_err<'a>(&'a self, err: impl SessionDiagnostic<'a>) -> ErrorGuaranteed { + pub fn emit_err<'a>(&'a self, err: impl IntoDiagnostic<'a>) -> ErrorGuaranteed { self.create_err(err).emit() } pub fn create_warning<'a>( &'a self, - warning: impl SessionDiagnostic<'a, ()>, + warning: impl IntoDiagnostic<'a, ()>, ) -> DiagnosticBuilder<'a, ()> { warning.into_diagnostic(&self.span_diagnostic) } - pub fn emit_warning<'a>(&'a self, warning: impl SessionDiagnostic<'a, ()>) { + pub fn emit_warning<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) { self.create_warning(warning).emit() } pub fn create_fatal<'a>( &'a self, - fatal: impl SessionDiagnostic<'a, !>, + fatal: impl IntoDiagnostic<'a, !>, ) -> DiagnosticBuilder<'a, !> { fatal.into_diagnostic(&self.span_diagnostic) } - pub fn emit_fatal<'a>(&'a self, fatal: impl SessionDiagnostic<'a, !>) -> ! { + pub fn emit_fatal<'a>(&'a self, fatal: impl IntoDiagnostic<'a, !>) -> ! { self.create_fatal(fatal).emit() } diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs index 6a5a89747df..e660b739928 100644 --- a/compiler/rustc_session/src/session.rs +++ b/compiler/rustc_session/src/session.rs @@ -27,8 +27,8 @@ use rustc_errors::emitter::{Emitter, EmitterWriter, HumanReadableErrorType}; use rustc_errors::json::JsonEmitter; use rustc_errors::registry::Registry; use rustc_errors::{ - error_code, fallback_fluent_bundle, DiagnosticBuilder, DiagnosticId, DiagnosticMessage, - ErrorGuaranteed, FluentBundle, LazyFallbackBundle, MultiSpan, SessionDiagnostic, + error_code, fallback_fluent_bundle, DiagnosticBuilder, IntoDiagnostic, DiagnosticId, + DiagnosticMessage, ErrorGuaranteed, FluentBundle, LazyFallbackBundle, MultiSpan, }; use rustc_macros::HashStable_Generic; pub use rustc_span::def_id::StableCrateId; @@ -505,13 +505,13 @@ impl Session { } pub fn create_err<'a>( &'a self, - err: impl SessionDiagnostic<'a>, + err: impl IntoDiagnostic<'a>, ) -> DiagnosticBuilder<'a, ErrorGuaranteed> { self.parse_sess.create_err(err) } pub fn create_feature_err<'a>( &'a self, - err: impl SessionDiagnostic<'a>, + err: impl IntoDiagnostic<'a>, feature: Symbol, ) -> DiagnosticBuilder<'a, ErrorGuaranteed> { let mut err = self.parse_sess.create_err(err); @@ -521,25 +521,25 @@ impl Session { add_feature_diagnostics(&mut err, &self.parse_sess, feature); err } - pub fn emit_err<'a>(&'a self, err: impl SessionDiagnostic<'a>) -> ErrorGuaranteed { + pub fn emit_err<'a>(&'a self, err: impl IntoDiagnostic<'a>) -> ErrorGuaranteed { self.parse_sess.emit_err(err) } pub fn create_warning<'a>( &'a self, - err: impl SessionDiagnostic<'a, ()>, + err: impl IntoDiagnostic<'a, ()>, ) -> DiagnosticBuilder<'a, ()> { self.parse_sess.create_warning(err) } - pub fn emit_warning<'a>(&'a self, warning: impl SessionDiagnostic<'a, ()>) { + pub fn emit_warning<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) { self.parse_sess.emit_warning(warning) } pub fn create_fatal<'a>( &'a self, - fatal: impl SessionDiagnostic<'a, !>, + fatal: impl IntoDiagnostic<'a, !>, ) -> DiagnosticBuilder<'a, !> { self.parse_sess.create_fatal(fatal) } - pub fn emit_fatal<'a>(&'a self, fatal: impl SessionDiagnostic<'a, !>) -> ! { + pub fn emit_fatal<'a>(&'a self, fatal: impl IntoDiagnostic<'a, !>) -> ! { self.parse_sess.emit_fatal(fatal) } #[inline] diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 562360130e9..98ff9694808 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -177,6 +177,7 @@ symbols! { DecorateLint, Default, Deref, + DiagnosticHandler, DiagnosticMessage, DirBuilder, Display, @@ -277,7 +278,6 @@ symbols! { RwLockWriteGuard, Send, SeqCst, - SessionDiagnostic, SliceIndex, Some, String, diff --git a/compiler/rustc_symbol_mangling/src/errors.rs b/compiler/rustc_symbol_mangling/src/errors.rs index 664d2543f1f..eb487a03c93 100644 --- a/compiler/rustc_symbol_mangling/src/errors.rs +++ b/compiler/rustc_symbol_mangling/src/errors.rs @@ -1,10 +1,10 @@ //! Errors emitted by symbol_mangling. use rustc_errors::{DiagnosticArgValue, IntoDiagnosticArg}; -use rustc_macros::SessionDiagnostic; +use rustc_macros::Diagnostic; use rustc_span::Span; -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(symbol_mangling::test_output)] pub struct TestOutput { #[primary_span] diff --git a/compiler/rustc_trait_selection/src/errors.rs b/compiler/rustc_trait_selection/src/errors.rs index dc7078d9ada..f62bdb00ee0 100644 --- a/compiler/rustc_trait_selection/src/errors.rs +++ b/compiler/rustc_trait_selection/src/errors.rs @@ -1,10 +1,10 @@ -use rustc_errors::{fluent, ErrorGuaranteed, Handler, SessionDiagnostic}; -use rustc_macros::SessionDiagnostic; +use rustc_errors::{fluent, IntoDiagnostic, ErrorGuaranteed, Handler}; +use rustc_macros::DiagnosticHandler; use rustc_middle::ty::{PolyTraitRef, Ty, Unevaluated}; use rustc_session::Limit; use rustc_span::{Span, Symbol}; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(trait_selection::dump_vtable_entries)] pub struct DumpVTableEntries<'a> { #[primary_span] @@ -13,7 +13,7 @@ pub struct DumpVTableEntries<'a> { pub entries: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(trait_selection::unable_to_construct_constant_value)] pub struct UnableToConstructConstantValue<'a> { #[primary_span] @@ -21,7 +21,7 @@ pub struct UnableToConstructConstantValue<'a> { pub unevaluated: Unevaluated<'a>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[help] #[diag(trait_selection::auto_deref_reached_recursion_limit, code = "E0055")] pub struct AutoDerefReachedRecursionLimit<'a> { @@ -33,7 +33,7 @@ pub struct AutoDerefReachedRecursionLimit<'a> { pub crate_name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(trait_selection::empty_on_clause_in_rustc_on_unimplemented, code = "E0232")] pub struct EmptyOnClauseInOnUnimplemented { #[primary_span] @@ -41,7 +41,7 @@ pub struct EmptyOnClauseInOnUnimplemented { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(trait_selection::invalid_on_clause_in_rustc_on_unimplemented, code = "E0232")] pub struct InvalidOnClauseInOnUnimplemented { #[primary_span] @@ -49,7 +49,7 @@ pub struct InvalidOnClauseInOnUnimplemented { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(trait_selection::no_value_in_rustc_on_unimplemented, code = "E0232")] #[note] pub struct NoValueInOnUnimplemented { @@ -66,7 +66,7 @@ pub struct NegativePositiveConflict<'a> { pub positive_impl_span: Result, } -impl SessionDiagnostic<'_> for NegativePositiveConflict<'_> { +impl IntoDiagnostic<'_> for NegativePositiveConflict<'_> { fn into_diagnostic( self, handler: &Handler, diff --git a/compiler/rustc_ty_utils/src/errors.rs b/compiler/rustc_ty_utils/src/errors.rs index 3a8ef96c991..995e87bcd3b 100644 --- a/compiler/rustc_ty_utils/src/errors.rs +++ b/compiler/rustc_ty_utils/src/errors.rs @@ -1,16 +1,16 @@ //! Errors emitted by ty_utils -use rustc_macros::{SessionDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{DiagnosticHandler, SessionSubdiagnostic}; use rustc_middle::ty::Ty; use rustc_span::Span; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(ty_utils::needs_drop_overflow)] pub struct NeedsDropOverflow<'tcx> { pub query_ty: Ty<'tcx>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(ty_utils::generic_constant_too_complex)] #[help] pub struct GenericConstantTooComplex { diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs index 93b00850069..11661b8ef6c 100644 --- a/compiler/rustc_typeck/src/check/expr.rs +++ b/compiler/rustc_typeck/src/check/expr.rs @@ -881,7 +881,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { return; } - // FIXME: Make this use SessionDiagnostic once error codes can be dynamically set. + // FIXME: Make this use DiagnosticHandler once error codes can be dynamically set. let mut err = self.tcx.sess.struct_span_err_with_code( op_span, "invalid left-hand side of assignment", diff --git a/compiler/rustc_typeck/src/errors.rs b/compiler/rustc_typeck/src/errors.rs index ed4c4f688bf..50d400e2921 100644 --- a/compiler/rustc_typeck/src/errors.rs +++ b/compiler/rustc_typeck/src/errors.rs @@ -1,11 +1,11 @@ //! Errors emitted by typeck. -use rustc_errors::SessionDiagnostic; +use rustc_errors::IntoDiagnostic; use rustc_errors::{error_code, Applicability, DiagnosticBuilder, ErrorGuaranteed, Handler}; -use rustc_macros::{LintDiagnostic, SessionDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{DiagnosticHandler, LintDiagnostic, SessionSubdiagnostic}; use rustc_middle::ty::Ty; use rustc_span::{symbol::Ident, Span, Symbol}; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::field_multiply_specified_in_initializer, code = "E0062")] pub struct FieldMultiplySpecifiedInInitializer { #[primary_span] @@ -16,7 +16,7 @@ pub struct FieldMultiplySpecifiedInInitializer { pub ident: Ident, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::unrecognized_atomic_operation, code = "E0092")] pub struct UnrecognizedAtomicOperation<'a> { #[primary_span] @@ -25,7 +25,7 @@ pub struct UnrecognizedAtomicOperation<'a> { pub op: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::wrong_number_of_generic_arguments_to_intrinsic, code = "E0094")] pub struct WrongNumberOfGenericArgumentsToIntrinsic<'a> { #[primary_span] @@ -36,7 +36,7 @@ pub struct WrongNumberOfGenericArgumentsToIntrinsic<'a> { pub descr: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::unrecognized_intrinsic_function, code = "E0093")] pub struct UnrecognizedIntrinsicFunction { #[primary_span] @@ -45,7 +45,7 @@ pub struct UnrecognizedIntrinsicFunction { pub name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::lifetimes_or_bounds_mismatch_on_trait, code = "E0195")] pub struct LifetimesOrBoundsMismatchOnTrait { #[primary_span] @@ -57,7 +57,7 @@ pub struct LifetimesOrBoundsMismatchOnTrait { pub ident: Ident, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::drop_impl_on_wrong_item, code = "E0120")] pub struct DropImplOnWrongItem { #[primary_span] @@ -65,7 +65,7 @@ pub struct DropImplOnWrongItem { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::field_already_declared, code = "E0124")] pub struct FieldAlreadyDeclared { pub field_name: Ident, @@ -76,7 +76,7 @@ pub struct FieldAlreadyDeclared { pub prev_span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::copy_impl_on_type_with_dtor, code = "E0184")] pub struct CopyImplOnTypeWithDtor { #[primary_span] @@ -84,14 +84,14 @@ pub struct CopyImplOnTypeWithDtor { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::multiple_relaxed_default_bounds, code = "E0203")] pub struct MultipleRelaxedDefaultBounds { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::copy_impl_on_non_adt, code = "E0206")] pub struct CopyImplOnNonAdt { #[primary_span] @@ -99,7 +99,7 @@ pub struct CopyImplOnNonAdt { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::trait_object_declared_with_no_traits, code = "E0224")] pub struct TraitObjectDeclaredWithNoTraits { #[primary_span] @@ -108,14 +108,14 @@ pub struct TraitObjectDeclaredWithNoTraits { pub trait_alias_span: Option, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0227")] pub struct AmbiguousLifetimeBound { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::assoc_type_binding_not_allowed, code = "E0229")] pub struct AssocTypeBindingNotAllowed { #[primary_span] @@ -123,14 +123,14 @@ pub struct AssocTypeBindingNotAllowed { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::functional_record_update_on_non_struct, code = "E0436")] pub struct FunctionalRecordUpdateOnNonStruct { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::typeof_reserved_keyword_used, code = "E0516")] pub struct TypeofReservedKeywordUsed<'tcx> { pub ty: Ty<'tcx>, @@ -141,7 +141,7 @@ pub struct TypeofReservedKeywordUsed<'tcx> { pub opt_sugg: Option<(Span, Applicability)>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::return_stmt_outside_of_fn_body, code = "E0572")] pub struct ReturnStmtOutsideOfFnBody { #[primary_span] @@ -152,14 +152,14 @@ pub struct ReturnStmtOutsideOfFnBody { pub encl_fn_span: Option, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::yield_expr_outside_of_generator, code = "E0627")] pub struct YieldExprOutsideOfGenerator { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::struct_expr_non_exhaustive, code = "E0639")] pub struct StructExprNonExhaustive { #[primary_span] @@ -167,14 +167,14 @@ pub struct StructExprNonExhaustive { pub what: &'static str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::method_call_on_unknown_type, code = "E0699")] pub struct MethodCallOnUnknownType { #[primary_span] pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::value_of_associated_struct_already_specified, code = "E0719")] pub struct ValueOfAssociatedStructAlreadySpecified { #[primary_span] @@ -186,7 +186,7 @@ pub struct ValueOfAssociatedStructAlreadySpecified { pub def_path: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::address_of_temporary_taken, code = "E0745")] pub struct AddressOfTemporaryTaken { #[primary_span] @@ -232,7 +232,7 @@ pub enum ExpectedReturnTypeLabel<'tcx> { }, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::unconstrained_opaque_type)] #[note] pub struct UnconstrainedOpaqueType { @@ -249,8 +249,8 @@ pub struct MissingTypeParams { pub empty_generic_args: bool, } -// Manual implementation of `SessionDiagnostic` to be able to call `span_to_snippet`. -impl<'a> SessionDiagnostic<'a> for MissingTypeParams { +// Manual implementation of `DiagnosticHandler` to be able to call `span_to_snippet`. +impl<'a> IntoDiagnostic<'a> for MissingTypeParams { fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> { let mut err = handler.struct_span_err_with_code( self.span, @@ -306,7 +306,7 @@ impl<'a> SessionDiagnostic<'a> for MissingTypeParams { } } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::manual_implementation, code = "E0183")] #[help] pub struct ManualImplementation { @@ -316,7 +316,7 @@ pub struct ManualImplementation { pub trait_name: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::substs_on_overridden_impl)] pub struct SubstsOnOverriddenImpl { #[primary_span] @@ -339,7 +339,7 @@ pub struct ExternCrateNotIdiomatic { pub suggestion_code: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::expected_used_symbol)] pub struct ExpectedUsedSymbol { #[primary_span] diff --git a/src/test/ui-fulldeps/internal-lints/diagnostics.rs b/src/test/ui-fulldeps/internal-lints/diagnostics.rs index 3b31a290449..1ead987ec41 100644 --- a/src/test/ui-fulldeps/internal-lints/diagnostics.rs +++ b/src/test/ui-fulldeps/internal-lints/diagnostics.rs @@ -12,12 +12,13 @@ extern crate rustc_session; extern crate rustc_span; use rustc_errors::{ - AddSubdiagnostic, SessionDiagnostic, Diagnostic, DiagnosticBuilder, ErrorGuaranteed, Handler, fluent + AddSubdiagnostic, IntoDiagnostic, Diagnostic, DiagnosticBuilder, + ErrorGuaranteed, Handler, fluent }; -use rustc_macros::{SessionDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{DiagnosticHandler, SessionSubdiagnostic}; use rustc_span::Span; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(parser::expect_path)] struct DeriveSessionDiagnostic { #[primary_span] @@ -33,7 +34,7 @@ struct Note { pub struct UntranslatableInSessionDiagnostic; -impl<'a> SessionDiagnostic<'a, ErrorGuaranteed> for UntranslatableInSessionDiagnostic { +impl<'a> IntoDiagnostic<'a, ErrorGuaranteed> for UntranslatableInSessionDiagnostic { fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> { handler.struct_err("untranslatable diagnostic") //~^ ERROR diagnostics should be created using translatable messages @@ -42,7 +43,7 @@ impl<'a> SessionDiagnostic<'a, ErrorGuaranteed> for UntranslatableInSessionDiagn pub struct TranslatableInSessionDiagnostic; -impl<'a> SessionDiagnostic<'a, ErrorGuaranteed> for TranslatableInSessionDiagnostic { +impl<'a> IntoDiagnostic<'a, ErrorGuaranteed> for TranslatableInSessionDiagnostic { fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> { handler.struct_err(fluent::parser::expect_path) } @@ -67,10 +68,10 @@ impl AddSubdiagnostic for TranslatableInAddSubdiagnostic { pub fn make_diagnostics<'a>(handler: &'a Handler) { let _diag = handler.struct_err(fluent::parser::expect_path); - //~^ ERROR diagnostics should only be created in `SessionDiagnostic`/`AddSubdiagnostic` impls + //~^ ERROR diagnostics should only be created in `IntoDiagnostic`/`AddSubdiagnostic` impls let _diag = handler.struct_err("untranslatable diagnostic"); - //~^ ERROR diagnostics should only be created in `SessionDiagnostic`/`AddSubdiagnostic` impls + //~^ ERROR diagnostics should only be created in `IntoDiagnostic`/`AddSubdiagnostic` impls //~^^ ERROR diagnostics should be created using translatable messages } diff --git a/src/test/ui-fulldeps/internal-lints/diagnostics.stderr b/src/test/ui-fulldeps/internal-lints/diagnostics.stderr index e5c5bc2e998..d5833cf3970 100644 --- a/src/test/ui-fulldeps/internal-lints/diagnostics.stderr +++ b/src/test/ui-fulldeps/internal-lints/diagnostics.stderr @@ -16,7 +16,7 @@ error: diagnostics should be created using translatable messages LL | diag.note("untranslatable diagnostic"); | ^^^^ -error: diagnostics should only be created in `SessionDiagnostic`/`AddSubdiagnostic` impls +error: diagnostics should only be created in `IntoDiagnostic`/`AddSubdiagnostic` impls --> $DIR/diagnostics.rs:70:25 | LL | let _diag = handler.struct_err(fluent::parser::expect_path); @@ -28,7 +28,7 @@ note: the lint level is defined here LL | #![deny(rustc::diagnostic_outside_of_impl)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error: diagnostics should only be created in `SessionDiagnostic`/`AddSubdiagnostic` impls +error: diagnostics should only be created in `IntoDiagnostic`/`AddSubdiagnostic` impls --> $DIR/diagnostics.rs:73:25 | LL | let _diag = handler.struct_err("untranslatable diagnostic"); diff --git a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs index c1c109ac1ea..32ba5be8963 100644 --- a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs +++ b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs @@ -1,10 +1,10 @@ // check-fail -// Tests error conditions for specifying diagnostics using #[derive(SessionDiagnostic)] +// Tests error conditions for specifying diagnostics using #[derive(DiagnosticHandler)] // normalize-stderr-test "the following other types implement trait `IntoDiagnosticArg`:(?:.*\n){0,9}\s+and \d+ others" -> "normalized in stderr" // normalize-stderr-test "diagnostic_builder\.rs:[0-9]+:[0-9]+" -> "diagnostic_builder.rs:LL:CC" // The proc_macro2 crate handles spans differently when on beta/stable release rather than nightly, -// changing the output of this test. Since SessionDiagnostic is strictly internal to the compiler +// changing the output of this test. Since DiagnosticHandler is strictly internal to the compiler // the test is just ignored on stable and beta: // ignore-beta // ignore-stable @@ -17,7 +17,7 @@ use rustc_span::symbol::Ident; use rustc_span::Span; extern crate rustc_macros; -use rustc_macros::{SessionDiagnostic, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{DiagnosticHandler, LintDiagnostic, SessionSubdiagnostic}; extern crate rustc_middle; use rustc_middle::ty::Ty; @@ -27,70 +27,70 @@ use rustc_errors::{Applicability, MultiSpan}; extern crate rustc_session; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct Hello {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct HelloWarn {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] -//~^ ERROR `#[derive(SessionDiagnostic)]` can only be used on structs -enum SessionDiagnosticOnEnum { +//~^ ERROR `#[derive(DiagnosticHandler)]` can only be used on structs +enum DiagnosticHandlerOnEnum { Foo, Bar, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[diag = "E0123"] //~^ ERROR `#[diag = ...]` is not a valid attribute struct WrongStructAttrStyle {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[nonsense(typeck::ambiguous_lifetime_bound, code = "E0123")] //~^ ERROR `#[nonsense(...)]` is not a valid attribute //~^^ ERROR diagnostic slug not specified //~^^^ ERROR cannot find attribute `nonsense` in this scope struct InvalidStructAttr {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag("E0123")] //~^ ERROR `#[diag("...")]` is not a valid attribute //~^^ ERROR diagnostic slug not specified struct InvalidLitNestedAttr {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(nonsense, code = "E0123")] //~^ ERROR cannot find value `nonsense` in module `rustc_errors::fluent` struct InvalidNestedStructAttr {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(nonsense("foo"), code = "E0123", slug = "foo")] //~^ ERROR `#[diag(nonsense(...))]` is not a valid attribute //~^^ ERROR diagnostic slug not specified struct InvalidNestedStructAttr1 {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(nonsense = "...", code = "E0123", slug = "foo")] //~^ ERROR `#[diag(nonsense = ...)]` is not a valid attribute //~^^ ERROR diagnostic slug not specified struct InvalidNestedStructAttr2 {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(nonsense = 4, code = "E0123", slug = "foo")] //~^ ERROR `#[diag(nonsense = ...)]` is not a valid attribute //~^^ ERROR diagnostic slug not specified struct InvalidNestedStructAttr3 {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123", slug = "foo")] //~^ ERROR `#[diag(slug = ...)]` is not a valid attribute struct InvalidNestedStructAttr4 {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct WrongPlaceField { #[suggestion = "bar"] @@ -98,36 +98,36 @@ struct WrongPlaceField { sp: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[diag(typeck::ambiguous_lifetime_bound, code = "E0456")] //~^ ERROR specified multiple times //~^^ ERROR specified multiple times struct DiagSpecifiedTwice {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0456", code = "E0457")] //~^ ERROR specified multiple times struct CodeSpecifiedTwice {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, typeck::ambiguous_lifetime_bound, code = "E0456")] //~^ ERROR `#[diag(typeck::ambiguous_lifetime_bound)]` is not a valid attribute struct SlugSpecifiedTwice {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] struct KindNotProvided {} //~ ERROR diagnostic slug not specified -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(code = "E0456")] //~^ ERROR diagnostic slug not specified struct SlugNotProvided {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound)] struct CodeNotProvided {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct MessageWrongType { #[primary_span] @@ -135,7 +135,7 @@ struct MessageWrongType { foo: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct InvalidPathFieldAttr { #[nonsense] @@ -144,7 +144,7 @@ struct InvalidPathFieldAttr { foo: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithField { name: String, @@ -152,7 +152,7 @@ struct ErrorWithField { span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithMessageAppliedToField { #[label(typeck::label)] @@ -160,7 +160,7 @@ struct ErrorWithMessageAppliedToField { name: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithNonexistentField { #[suggestion(typeck::suggestion, code = "{name}")] @@ -168,7 +168,7 @@ struct ErrorWithNonexistentField { suggestion: (Span, Applicability), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] //~^ ERROR invalid format string: expected `'}'` #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorMissingClosingBrace { @@ -178,7 +178,7 @@ struct ErrorMissingClosingBrace { val: usize, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] //~^ ERROR invalid format string: unmatched `}` #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorMissingOpeningBrace { @@ -188,14 +188,14 @@ struct ErrorMissingOpeningBrace { val: usize, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct LabelOnSpan { #[label(typeck::label)] sp: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct LabelOnNonSpan { #[label(typeck::label)] @@ -203,7 +203,7 @@ struct LabelOnNonSpan { id: u32, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct Suggest { #[suggestion(typeck::suggestion, code = "This is the suggested code")] @@ -213,14 +213,14 @@ struct Suggest { suggestion: (Span, Applicability), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithoutCode { #[suggestion(typeck::suggestion)] suggestion: (Span, Applicability), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithBadKey { #[suggestion(nonsense = "bar")] @@ -228,7 +228,7 @@ struct SuggestWithBadKey { suggestion: (Span, Applicability), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithShorthandMsg { #[suggestion(msg = "bar")] @@ -236,21 +236,21 @@ struct SuggestWithShorthandMsg { suggestion: (Span, Applicability), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithoutMsg { #[suggestion(code = "bar")] suggestion: (Span, Applicability), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithTypesSwapped { #[suggestion(typeck::suggestion, code = "This is suggested code")] suggestion: (Applicability, Span), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithWrongTypeApplicabilityOnly { #[suggestion(typeck::suggestion, code = "This is suggested code")] @@ -258,14 +258,14 @@ struct SuggestWithWrongTypeApplicabilityOnly { suggestion: Applicability, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithSpanOnly { #[suggestion(typeck::suggestion, code = "This is suggested code")] suggestion: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithDuplicateSpanAndApplicability { #[suggestion(typeck::suggestion, code = "This is suggested code")] @@ -273,7 +273,7 @@ struct SuggestWithDuplicateSpanAndApplicability { suggestion: (Span, Span, Applicability), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithDuplicateApplicabilityAndSpan { #[suggestion(typeck::suggestion, code = "This is suggested code")] @@ -281,7 +281,7 @@ struct SuggestWithDuplicateApplicabilityAndSpan { suggestion: (Applicability, Applicability, Span), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct WrongKindOfAnnotation { #[label = "bar"] @@ -289,7 +289,7 @@ struct WrongKindOfAnnotation { z: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct OptionsInErrors { #[label(typeck::label)] @@ -298,7 +298,7 @@ struct OptionsInErrors { opt_sugg: Option<(Span, Applicability)>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0456")] struct MoveOutOfBorrowError<'tcx> { name: Ident, @@ -312,7 +312,7 @@ struct MoveOutOfBorrowError<'tcx> { opt_sugg: Option<(Span, Applicability)>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithLifetime<'a> { #[label(typeck::label)] @@ -320,7 +320,7 @@ struct ErrorWithLifetime<'a> { name: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithDefaultLabelAttr<'a> { #[label] @@ -328,7 +328,7 @@ struct ErrorWithDefaultLabelAttr<'a> { name: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] //~^ ERROR the trait bound `Hello: IntoDiagnosticArg` is not satisfied #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ArgFieldWithoutSkip { @@ -337,7 +337,7 @@ struct ArgFieldWithoutSkip { other: Hello, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ArgFieldWithSkip { #[primary_span] @@ -348,91 +348,91 @@ struct ArgFieldWithSkip { other: Hello, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithSpannedNote { #[note] span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithSpannedNoteCustom { #[note(typeck::note)] span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[note] struct ErrorWithNote { val: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[note(typeck::note)] struct ErrorWithNoteCustom { val: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithSpannedHelp { #[help] span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithSpannedHelpCustom { #[help(typeck::help)] span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[help] struct ErrorWithHelp { val: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[help(typeck::help)] struct ErrorWithHelpCustom { val: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[help] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithHelpWrongOrder { val: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[help(typeck::help)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithHelpCustomWrongOrder { val: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[note] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithNoteWrongOrder { val: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[note(typeck::note)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithNoteCustomWrongOrder { val: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ApplicabilityInBoth { #[suggestion(typeck::suggestion, code = "...", applicability = "maybe-incorrect")] @@ -440,7 +440,7 @@ struct ApplicabilityInBoth { suggestion: (Span, Applicability), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct InvalidApplicability { #[suggestion(typeck::suggestion, code = "...", applicability = "batman")] @@ -448,14 +448,14 @@ struct InvalidApplicability { suggestion: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ValidApplicability { #[suggestion(typeck::suggestion, code = "...", applicability = "maybe-incorrect")] suggestion: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct NoApplicability { #[suggestion(typeck::suggestion, code = "...")] @@ -466,14 +466,14 @@ struct NoApplicability { #[note(parser::add_paren)] struct Note; -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound)] struct Subdiagnostic { #[subdiagnostic] note: Note, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct VecField { #[primary_span] @@ -481,7 +481,7 @@ struct VecField { spans: Vec, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct UnitField { #[primary_span] @@ -492,7 +492,7 @@ struct UnitField { bar: (), } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct OptUnitField { #[primary_span] @@ -503,7 +503,7 @@ struct OptUnitField { bar: Option<()>, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct LabelWithTrailingPath { #[label(typeck::label, foo)] @@ -511,7 +511,7 @@ struct LabelWithTrailingPath { span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct LabelWithTrailingNameValue { #[label(typeck::label, foo = "...")] @@ -519,7 +519,7 @@ struct LabelWithTrailingNameValue { span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct LabelWithTrailingList { #[label(typeck::label, foo("..."))] @@ -540,35 +540,35 @@ struct PrimarySpanOnLint { span: Span, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithMultiSpan { #[primary_span] span: MultiSpan, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[warning] struct ErrorWithWarn { val: String, } -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[error(typeck::ambiguous_lifetime_bound, code = "E0123")] //~^ ERROR `#[error(...)]` is not a valid attribute //~| ERROR diagnostic slug not specified //~| ERROR cannot find attribute `error` in this scope struct ErrorAttribute {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[warn_(typeck::ambiguous_lifetime_bound, code = "E0123")] //~^ ERROR `#[warn_(...)]` is not a valid attribute //~| ERROR diagnostic slug not specified //~| ERROR cannot find attribute `warn_` in this scope struct WarnAttribute {} -#[derive(SessionDiagnostic)] +#[derive(DiagnosticHandler)] #[lint(typeck::ambiguous_lifetime_bound, code = "E0123")] //~^ ERROR `#[lint(...)]` is not a valid attribute //~| ERROR diagnostic slug not specified diff --git a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr index ab5c28fe473..d9198d4ef80 100644 --- a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr +++ b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr @@ -1,9 +1,9 @@ -error: `#[derive(SessionDiagnostic)]` can only be used on structs +error: `#[derive(DiagnosticHandler)]` can only be used on structs --> $DIR/diagnostic-derive.rs:39:1 | LL | / #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] LL | | -LL | | enum SessionDiagnosticOnEnum { +LL | | enum DiagnosticHandlerOnEnum { LL | | Foo, LL | | Bar, LL | | } @@ -214,22 +214,22 @@ LL | #[suggestion(typeck::suggestion, code = "{name}")] error: invalid format string: expected `'}'` but string was terminated --> $DIR/diagnostic-derive.rs:171:16 | -LL | #[derive(SessionDiagnostic)] +LL | #[derive(DiagnosticHandler)] | - ^ expected `'}'` in format string | | | because of this opening brace | = note: if you intended to print `{`, you can escape it using `{{` - = note: this error originates in the derive macro `SessionDiagnostic` (in Nightly builds, run with -Z macro-backtrace for more info) + = note: this error originates in the derive macro `DiagnosticHandler` (in Nightly builds, run with -Z macro-backtrace for more info) error: invalid format string: unmatched `}` found --> $DIR/diagnostic-derive.rs:181:15 | -LL | #[derive(SessionDiagnostic)] +LL | #[derive(DiagnosticHandler)] | ^ unmatched `}` in format string | = note: if you intended to print `}`, you can escape it using `}}` - = note: this error originates in the derive macro `SessionDiagnostic` (in Nightly builds, run with -Z macro-backtrace for more info) + = note: this error originates in the derive macro `DiagnosticHandler` (in Nightly builds, run with -Z macro-backtrace for more info) error: the `#[label(...)]` attribute can only be applied to fields of type `Span` or `MultiSpan` --> $DIR/diagnostic-derive.rs:201:5 @@ -448,7 +448,7 @@ LL | #[diag(nonsense, code = "E0123")] error[E0277]: the trait bound `Hello: IntoDiagnosticArg` is not satisfied --> $DIR/diagnostic-derive.rs:331:10 | -LL | #[derive(SessionDiagnostic)] +LL | #[derive(DiagnosticHandler)] | ^^^^^^^^^^^^^^^^^ the trait `IntoDiagnosticArg` is not implemented for `Hello` | = help: normalized in stderr @@ -457,7 +457,7 @@ note: required by a bound in `DiagnosticBuilder::<'a, G>::set_arg` | LL | arg: impl IntoDiagnosticArg, | ^^^^^^^^^^^^^^^^^ required by this bound in `DiagnosticBuilder::<'a, G>::set_arg` - = note: this error originates in the derive macro `SessionDiagnostic` (in Nightly builds, run with -Z macro-backtrace for more info) + = note: this error originates in the derive macro `DiagnosticHandler` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to 55 previous errors -- cgit 1.4.1-3-g733a5 From a3396b207093c01065b63b0c58f1e6654629166d Mon Sep 17 00:00:00 2001 From: Jhonny Bill Mena Date: Sun, 18 Sep 2022 11:46:56 -0400 Subject: UPDATE - rename DiagnosticHandler macro to Diagnostic --- compiler/rustc_ast_lowering/src/errors.rs | 66 ++++----- compiler/rustc_attr/src/session_diagnostics.rs | 60 ++++---- compiler/rustc_borrowck/src/session_diagnostics.rs | 16 +-- compiler/rustc_builtin_macros/src/cfg.rs | 6 +- compiler/rustc_const_eval/src/errors.rs | 44 +++--- compiler/rustc_driver/src/session_diagnostics.rs | 16 +-- compiler/rustc_errors/src/diagnostic_builder.rs | 4 +- compiler/rustc_expand/src/errors.rs | 14 +- compiler/rustc_interface/src/errors.rs | 30 ++-- compiler/rustc_lint/src/errors.rs | 18 +-- compiler/rustc_lint/src/internal.rs | 4 +- .../rustc_macros/src/diagnostics/diagnostic.rs | 4 +- .../src/diagnostics/diagnostic_builder.rs | 6 +- compiler/rustc_macros/src/diagnostics/mod.rs | 6 +- compiler/rustc_macros/src/lib.rs | 2 +- compiler/rustc_metadata/src/errors.rs | 154 ++++++++++----------- compiler/rustc_middle/src/error.rs | 8 +- compiler/rustc_mir_dataflow/src/errors.rs | 22 +-- compiler/rustc_monomorphize/src/errors.rs | 12 +- compiler/rustc_parse/src/parser/diagnostics.rs | 84 +++++------ compiler/rustc_passes/src/errors.rs | 104 +++++++------- compiler/rustc_plugin_impl/src/errors.rs | 6 +- compiler/rustc_privacy/src/errors.rs | 12 +- compiler/rustc_query_system/src/error.rs | 6 +- compiler/rustc_save_analysis/src/errors.rs | 4 +- compiler/rustc_session/src/errors.rs | 8 +- compiler/rustc_span/src/symbol.rs | 2 +- compiler/rustc_trait_selection/src/errors.rs | 14 +- compiler/rustc_ty_utils/src/errors.rs | 6 +- compiler/rustc_typeck/src/check/expr.rs | 2 +- compiler/rustc_typeck/src/errors.rs | 54 ++++---- src/test/ui-fulldeps/internal-lints/diagnostics.rs | 4 +- .../session-diagnostic/diagnostic-derive.rs | 154 ++++++++++----------- .../session-diagnostic/diagnostic-derive.stderr | 16 +-- 34 files changed, 484 insertions(+), 484 deletions(-) (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs index 75f20b07277..6dbb2582a37 100644 --- a/compiler/rustc_ast_lowering/src/errors.rs +++ b/compiler/rustc_ast_lowering/src/errors.rs @@ -1,8 +1,8 @@ use rustc_errors::{fluent, AddToDiagnostic, Applicability, Diagnostic, DiagnosticArgFromDisplay}; -use rustc_macros::{DiagnosticHandler, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, SessionSubdiagnostic}; use rustc_span::{symbol::Ident, Span, Symbol}; -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::generic_type_with_parentheses, code = "E0214")] pub struct GenericTypeWithParentheses { #[primary_span] @@ -28,7 +28,7 @@ impl AddToDiagnostic for UseAngleBrackets { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[help] #[diag(ast_lowering::invalid_abi, code = "E0703")] pub struct InvalidAbi { @@ -39,7 +39,7 @@ pub struct InvalidAbi { pub valid_abis: String, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::assoc_ty_parentheses)] pub struct AssocTyParentheses { #[primary_span] @@ -71,7 +71,7 @@ impl AddToDiagnostic for AssocTyParenthesesSub { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(ast_lowering::misplaced_impl_trait, code = "E0562")] pub struct MisplacedImplTrait<'a> { #[primary_span] @@ -79,14 +79,14 @@ pub struct MisplacedImplTrait<'a> { pub position: DiagnosticArgFromDisplay<'a>, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::rustc_box_attribute_error)] pub struct RustcBoxAttributeError { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::underscore_expr_lhs_assign)] pub struct UnderscoreExprLhsAssign { #[primary_span] @@ -94,7 +94,7 @@ pub struct UnderscoreExprLhsAssign { pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::base_expression_double_dot)] pub struct BaseExpressionDoubleDot { #[primary_span] @@ -102,7 +102,7 @@ pub struct BaseExpressionDoubleDot { pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::await_only_in_async_fn_and_blocks, code = "E0728")] pub struct AwaitOnlyInAsyncFnAndBlocks { #[primary_span] @@ -112,21 +112,21 @@ pub struct AwaitOnlyInAsyncFnAndBlocks { pub item_span: Option, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::generator_too_many_parameters, code = "E0628")] pub struct GeneratorTooManyParameters { #[primary_span] pub fn_decl_span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::closure_cannot_be_static, code = "E0697")] pub struct ClosureCannotBeStatic { #[primary_span] pub fn_decl_span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[help] #[diag(ast_lowering::async_non_move_closure_not_supported, code = "E0708")] pub struct AsyncNonMoveClosureNotSupported { @@ -134,7 +134,7 @@ pub struct AsyncNonMoveClosureNotSupported { pub fn_decl_span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::functional_record_update_destructuring_assignment)] pub struct FunctionalRecordUpdateDestructuringAssignemnt { #[primary_span] @@ -142,28 +142,28 @@ pub struct FunctionalRecordUpdateDestructuringAssignemnt { pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::async_generators_not_supported, code = "E0727")] pub struct AsyncGeneratorsNotSupported { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::inline_asm_unsupported_target, code = "E0472")] pub struct InlineAsmUnsupportedTarget { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::att_syntax_only_x86)] pub struct AttSyntaxOnlyX86 { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::abi_specified_multiple_times)] pub struct AbiSpecifiedMultipleTimes { #[primary_span] @@ -175,14 +175,14 @@ pub struct AbiSpecifiedMultipleTimes { pub equivalent: Option<()>, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::clobber_abi_not_supported)] pub struct ClobberAbiNotSupported { #[primary_span] pub abi_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[note] #[diag(ast_lowering::invalid_abi_clobber_abi)] pub struct InvalidAbiClobberAbi { @@ -191,7 +191,7 @@ pub struct InvalidAbiClobberAbi { pub supported_abis: String, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::invalid_register)] pub struct InvalidRegister<'a> { #[primary_span] @@ -200,7 +200,7 @@ pub struct InvalidRegister<'a> { pub error: &'a str, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::invalid_register_class)] pub struct InvalidRegisterClass<'a> { #[primary_span] @@ -209,7 +209,7 @@ pub struct InvalidRegisterClass<'a> { pub error: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(ast_lowering::invalid_asm_template_modifier_reg_class)] pub struct InvalidAsmTemplateModifierRegClass { #[primary_span] @@ -229,7 +229,7 @@ pub enum InvalidAsmTemplateModifierRegClassSub { DoesNotSupportModifier { class_name: Symbol }, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::invalid_asm_template_modifier_const)] pub struct InvalidAsmTemplateModifierConst { #[primary_span] @@ -239,7 +239,7 @@ pub struct InvalidAsmTemplateModifierConst { pub op_span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::invalid_asm_template_modifier_sym)] pub struct InvalidAsmTemplateModifierSym { #[primary_span] @@ -249,7 +249,7 @@ pub struct InvalidAsmTemplateModifierSym { pub op_span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::register_class_only_clobber)] pub struct RegisterClassOnlyClobber { #[primary_span] @@ -257,7 +257,7 @@ pub struct RegisterClassOnlyClobber { pub reg_class_name: Symbol, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::register_conflict)] pub struct RegisterConflict<'a> { #[primary_span] @@ -271,7 +271,7 @@ pub struct RegisterConflict<'a> { pub in_out: Option, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[help] #[diag(ast_lowering::sub_tuple_binding)] pub struct SubTupleBinding<'a> { @@ -288,7 +288,7 @@ pub struct SubTupleBinding<'a> { pub ctx: &'a str, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::extra_double_dot)] pub struct ExtraDoubleDot<'a> { #[primary_span] @@ -299,7 +299,7 @@ pub struct ExtraDoubleDot<'a> { pub ctx: &'a str, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[note] #[diag(ast_lowering::misplaced_double_dot)] pub struct MisplacedDoubleDot { @@ -307,28 +307,28 @@ pub struct MisplacedDoubleDot { pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::misplaced_relax_trait_bound)] pub struct MisplacedRelaxTraitBound { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::not_supported_for_lifetime_binder_async_closure)] pub struct NotSupportedForLifetimeBinderAsyncClosure { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::arbitrary_expression_in_pattern)] pub struct ArbitraryExpressionInPattern { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::inclusive_range_with_no_end)] pub struct InclusiveRangeWithNoEnd { #[primary_span] diff --git a/compiler/rustc_attr/src/session_diagnostics.rs b/compiler/rustc_attr/src/session_diagnostics.rs index 8362b51af40..5e8f9b79850 100644 --- a/compiler/rustc_attr/src/session_diagnostics.rs +++ b/compiler/rustc_attr/src/session_diagnostics.rs @@ -5,19 +5,19 @@ use rustc_errors::{ error_code, fluent, Applicability, DiagnosticBuilder, IntoDiagnostic, ErrorGuaranteed, Handler, }; -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use rustc_span::{Span, Symbol}; use crate::UnsupportedLiteralReason; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::expected_one_cfg_pattern, code = "E0536")] pub(crate) struct ExpectedOneCfgPattern { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::invalid_predicate, code = "E0537")] pub(crate) struct InvalidPredicate { #[primary_span] @@ -26,7 +26,7 @@ pub(crate) struct InvalidPredicate { pub predicate: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::multiple_item, code = "E0538")] pub(crate) struct MultipleItem { #[primary_span] @@ -35,7 +35,7 @@ pub(crate) struct MultipleItem { pub item: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::incorrect_meta_item, code = "E0539")] pub(crate) struct IncorrectMetaItem { #[primary_span] @@ -65,28 +65,28 @@ impl<'a> IntoDiagnostic<'a> for UnknownMetaItem<'_> { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::missing_since, code = "E0542")] pub(crate) struct MissingSince { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::missing_note, code = "E0543")] pub(crate) struct MissingNote { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::multiple_stability_levels, code = "E0544")] pub(crate) struct MultipleStabilityLevels { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::invalid_issue_string, code = "E0545")] pub(crate) struct InvalidIssueString { #[primary_span] @@ -144,21 +144,21 @@ impl InvalidIssueStringCause { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::missing_feature, code = "E0546")] pub(crate) struct MissingFeature { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::non_ident_feature, code = "E0546")] pub(crate) struct NonIdentFeature { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::missing_issue, code = "E0547")] pub(crate) struct MissingIssue { #[primary_span] @@ -167,7 +167,7 @@ pub(crate) struct MissingIssue { // FIXME: This diagnostic is identical to `IncorrectMetaItem`, barring the error code. Consider // changing this to `IncorrectMetaItem`. See #51489. -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::incorrect_meta_item, code = "E0551")] pub(crate) struct IncorrectMetaItem2 { #[primary_span] @@ -176,14 +176,14 @@ pub(crate) struct IncorrectMetaItem2 { // FIXME: Why is this the same error code as `InvalidReprHintNoParen` and `InvalidReprHintNoValue`? // It is more similar to `IncorrectReprFormatGeneric`. -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::incorrect_repr_format_packed_one_or_zero_arg, code = "E0552")] pub(crate) struct IncorrectReprFormatPackedOneOrZeroArg { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::invalid_repr_hint_no_paren, code = "E0552")] pub(crate) struct InvalidReprHintNoParen { #[primary_span] @@ -192,7 +192,7 @@ pub(crate) struct InvalidReprHintNoParen { pub name: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::invalid_repr_hint_no_value, code = "E0552")] pub(crate) struct InvalidReprHintNoValue { #[primary_span] @@ -237,7 +237,7 @@ impl<'a> IntoDiagnostic<'a> for UnsupportedLiteral { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::invalid_repr_align_need_arg, code = "E0589")] pub(crate) struct InvalidReprAlignNeedArg { #[primary_span] @@ -245,7 +245,7 @@ pub(crate) struct InvalidReprAlignNeedArg { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::invalid_repr_generic, code = "E0589")] pub(crate) struct InvalidReprGeneric<'a> { #[primary_span] @@ -255,14 +255,14 @@ pub(crate) struct InvalidReprGeneric<'a> { pub error_part: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::incorrect_repr_format_align_one_arg, code = "E0693")] pub(crate) struct IncorrectReprFormatAlignOneArg { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::incorrect_repr_format_generic, code = "E0693")] pub(crate) struct IncorrectReprFormatGeneric<'a> { #[primary_span] @@ -317,28 +317,28 @@ impl<'a> IncorrectReprFormatGenericCause<'a> { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::rustc_promotable_pairing, code = "E0717")] pub(crate) struct RustcPromotablePairing { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::rustc_allowed_unstable_pairing, code = "E0789")] pub(crate) struct RustcAllowedUnstablePairing { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::cfg_predicate_identifier)] pub(crate) struct CfgPredicateIdentifier { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::deprecated_item_suggestion)] pub(crate) struct DeprecatedItemSuggestion { #[primary_span] @@ -351,21 +351,21 @@ pub(crate) struct DeprecatedItemSuggestion { pub details: (), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::expected_single_version_literal)] pub(crate) struct ExpectedSingleVersionLiteral { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::expected_version_literal)] pub(crate) struct ExpectedVersionLiteral { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::expects_feature_list)] pub(crate) struct ExpectsFeatureList { #[primary_span] @@ -374,7 +374,7 @@ pub(crate) struct ExpectsFeatureList { pub name: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::expects_features)] pub(crate) struct ExpectsFeatures { #[primary_span] @@ -383,14 +383,14 @@ pub(crate) struct ExpectsFeatures { pub name: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::soft_no_args)] pub(crate) struct SoftNoArgs { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(attr::unknown_version_literal)] pub(crate) struct UnknownVersionLiteral { #[primary_span] diff --git a/compiler/rustc_borrowck/src/session_diagnostics.rs b/compiler/rustc_borrowck/src/session_diagnostics.rs index 1014a92cc39..aa8f26eece5 100644 --- a/compiler/rustc_borrowck/src/session_diagnostics.rs +++ b/compiler/rustc_borrowck/src/session_diagnostics.rs @@ -1,11 +1,11 @@ use rustc_errors::{IntoDiagnosticArg, MultiSpan}; -use rustc_macros::{DiagnosticHandler, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic, SessionSubdiagnostic}; use rustc_middle::ty::Ty; use rustc_span::Span; use crate::diagnostics::RegionName; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(borrowck::move_unsized, code = "E0161")] pub(crate) struct MoveUnsized<'tcx> { pub ty: Ty<'tcx>, @@ -14,7 +14,7 @@ pub(crate) struct MoveUnsized<'tcx> { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(borrowck::higher_ranked_lifetime_error)] pub(crate) struct HigherRankedLifetimeError { #[subdiagnostic] @@ -31,14 +31,14 @@ pub(crate) enum HigherRankedErrorCause { CouldNotNormalize { value: String }, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(borrowck::higher_ranked_subtype_error)] pub(crate) struct HigherRankedSubtypeError { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(borrowck::generic_does_not_live_long_enough)] pub(crate) struct GenericDoesNotLiveLongEnough { pub kind: String, @@ -53,7 +53,7 @@ pub(crate) struct VarNeedNotMut { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(borrowck::const_not_used_in_type_alias)] pub(crate) struct ConstNotUsedTraitAlias { pub ct: String, @@ -61,7 +61,7 @@ pub(crate) struct ConstNotUsedTraitAlias { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(borrowck::var_cannot_escape_closure)] #[note] #[note(borrowck::cannot_escape)] @@ -110,7 +110,7 @@ pub(crate) enum FnMutReturnTypeErr { }, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(borrowck::lifetime_constraints_error)] pub(crate) struct LifetimeOutliveErr { #[primary_span] diff --git a/compiler/rustc_builtin_macros/src/cfg.rs b/compiler/rustc_builtin_macros/src/cfg.rs index 55b54fede93..46b54eae384 100644 --- a/compiler/rustc_builtin_macros/src/cfg.rs +++ b/compiler/rustc_builtin_macros/src/cfg.rs @@ -8,7 +8,7 @@ use rustc_ast::tokenstream::TokenStream; use rustc_attr as attr; use rustc_errors::PResult; use rustc_expand::base::{self, *}; -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use rustc_span::Span; pub fn expand_cfg( @@ -35,7 +35,7 @@ pub fn expand_cfg( } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(builtin_macros::requires_cfg_pattern)] struct RequiresCfgPattern { #[primary_span] @@ -43,7 +43,7 @@ struct RequiresCfgPattern { span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(builtin_macros::expected_one_cfg_pattern)] struct OneCfgPattern { #[primary_span] diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs index d0b94e91abf..c6cb7a8b961 100644 --- a/compiler/rustc_const_eval/src/errors.rs +++ b/compiler/rustc_const_eval/src/errors.rs @@ -1,8 +1,8 @@ use rustc_hir::ConstContext; -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use rustc_span::Span; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::unstable_in_stable)] pub(crate) struct UnstableInStable { pub gate: String, @@ -21,14 +21,14 @@ pub(crate) struct UnstableInStable { pub attr_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::thread_local_access, code = "E0625")] pub(crate) struct NonConstOpErr { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::static_access, code = "E0013")] #[help] pub(crate) struct StaticAccessErr { @@ -40,7 +40,7 @@ pub(crate) struct StaticAccessErr { pub teach: Option<()>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::raw_ptr_to_int)] #[note] #[note(const_eval::note2)] @@ -49,7 +49,7 @@ pub(crate) struct RawPtrToIntErr { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::raw_ptr_comparison)] #[note] pub(crate) struct RawPtrComparisonErr { @@ -57,14 +57,14 @@ pub(crate) struct RawPtrComparisonErr { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::panic_non_str)] pub(crate) struct PanicNonStrErr { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::mut_deref, code = "E0658")] pub(crate) struct MutDerefErr { #[primary_span] @@ -72,7 +72,7 @@ pub(crate) struct MutDerefErr { pub kind: ConstContext, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::transient_mut_borrow, code = "E0658")] pub(crate) struct TransientMutBorrowErr { #[primary_span] @@ -80,7 +80,7 @@ pub(crate) struct TransientMutBorrowErr { pub kind: ConstContext, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::transient_mut_borrow_raw, code = "E0658")] pub(crate) struct TransientMutBorrowErrRaw { #[primary_span] @@ -88,7 +88,7 @@ pub(crate) struct TransientMutBorrowErrRaw { pub kind: ConstContext, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::max_num_nodes_in_const)] pub(crate) struct MaxNumNodesInConstErr { #[primary_span] @@ -96,7 +96,7 @@ pub(crate) struct MaxNumNodesInConstErr { pub global_const_id: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::unallowed_fn_pointer_call)] pub(crate) struct UnallowedFnPointerCall { #[primary_span] @@ -104,7 +104,7 @@ pub(crate) struct UnallowedFnPointerCall { pub kind: ConstContext, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::unstable_const_fn)] pub(crate) struct UnstableConstFn { #[primary_span] @@ -112,7 +112,7 @@ pub(crate) struct UnstableConstFn { pub def_path: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::unallowed_mutable_refs, code = "E0764")] pub(crate) struct UnallowedMutableRefs { #[primary_span] @@ -122,7 +122,7 @@ pub(crate) struct UnallowedMutableRefs { pub teach: Option<()>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::unallowed_mutable_refs_raw, code = "E0764")] pub(crate) struct UnallowedMutableRefsRaw { #[primary_span] @@ -131,7 +131,7 @@ pub(crate) struct UnallowedMutableRefsRaw { #[note(const_eval::teach_note)] pub teach: Option<()>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::non_const_fmt_macro_call, code = "E0015")] pub(crate) struct NonConstFmtMacroCall { #[primary_span] @@ -139,7 +139,7 @@ pub(crate) struct NonConstFmtMacroCall { pub kind: ConstContext, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::non_const_fn_call, code = "E0015")] pub(crate) struct NonConstFnCall { #[primary_span] @@ -148,7 +148,7 @@ pub(crate) struct NonConstFnCall { pub kind: ConstContext, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::unallowed_op_in_const_context)] pub(crate) struct UnallowedOpInConstContext { #[primary_span] @@ -156,7 +156,7 @@ pub(crate) struct UnallowedOpInConstContext { pub msg: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::unallowed_heap_allocations, code = "E0010")] pub(crate) struct UnallowedHeapAllocations { #[primary_span] @@ -167,7 +167,7 @@ pub(crate) struct UnallowedHeapAllocations { pub teach: Option<()>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::unallowed_inline_asm, code = "E0015")] pub(crate) struct UnallowedInlineAsm { #[primary_span] @@ -175,7 +175,7 @@ pub(crate) struct UnallowedInlineAsm { pub kind: ConstContext, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::interior_mutable_data_refer, code = "E0492")] pub(crate) struct InteriorMutableDataRefer { #[primary_span] @@ -188,7 +188,7 @@ pub(crate) struct InteriorMutableDataRefer { pub teach: Option<()>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(const_eval::interior_mutability_borrow)] pub(crate) struct InteriorMutabilityBorrow { #[primary_span] diff --git a/compiler/rustc_driver/src/session_diagnostics.rs b/compiler/rustc_driver/src/session_diagnostics.rs index 704d3c7fd2a..289baf17773 100644 --- a/compiler/rustc_driver/src/session_diagnostics.rs +++ b/compiler/rustc_driver/src/session_diagnostics.rs @@ -1,38 +1,38 @@ -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(driver::rlink_unable_to_read)] pub(crate) struct RlinkUnableToRead { pub err: std::io::Error, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(driver::rlink_wrong_file_type)] pub(crate) struct RLinkWrongFileType; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(driver::rlink_empty_version_number)] pub(crate) struct RLinkEmptyVersionNumber; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(driver::rlink_encoding_version_mismatch)] pub(crate) struct RLinkEncodingVersionMismatch { pub version_array: String, pub rlink_version: u32, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(driver::rlink_rustc_version_mismatch)] pub(crate) struct RLinkRustcVersionMismatch<'a> { pub rustc_version: String, pub current_version: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(driver::rlink_no_a_file)] pub(crate) struct RlinkNotAFile; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(driver::unpretty_dump_fail)] pub(crate) struct UnprettyDumpFail { pub path: String, diff --git a/compiler/rustc_errors/src/diagnostic_builder.rs b/compiler/rustc_errors/src/diagnostic_builder.rs index 209a50fd306..f9b46053486 100644 --- a/compiler/rustc_errors/src/diagnostic_builder.rs +++ b/compiler/rustc_errors/src/diagnostic_builder.rs @@ -14,9 +14,9 @@ use std::ops::{Deref, DerefMut}; use std::thread::panicking; /// Trait implemented by error types. This should not be implemented manually. Instead, use -/// `#[derive(DiagnosticHandler)]` -- see [rustc_macros::DiagnosticHandler]. +/// `#[derive(Diagnostic)]` -- see [rustc_macros::Diagnostic]. #[cfg_attr(bootstrap, rustc_diagnostic_item = "SessionDiagnostic")] -#[cfg_attr(not(bootstrap), rustc_diagnostic_item = "DiagnosticHandler")] +#[cfg_attr(not(bootstrap), rustc_diagnostic_item = "Diagnostic")] pub trait IntoDiagnostic<'a, T: EmissionGuarantee = ErrorGuaranteed> { /// Write out as a diagnostic out of `Handler`. #[must_use] diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs index 7cbdad3cd95..bd93f0717f5 100644 --- a/compiler/rustc_expand/src/errors.rs +++ b/compiler/rustc_expand/src/errors.rs @@ -1,29 +1,29 @@ -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use rustc_span::symbol::MacroRulesNormalizedIdent; use rustc_span::Span; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(expand::expr_repeat_no_syntax_vars)] pub(crate) struct NoSyntaxVarsExprRepeat { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(expand::must_repeat_once)] pub(crate) struct MustRepeatOnce { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(expand::count_repetition_misplaced)] pub(crate) struct CountRepetitionMisplaced { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(expand::meta_var_expr_unrecognized_var)] pub(crate) struct MetaVarExprUnrecognizedVar { #[primary_span] @@ -31,7 +31,7 @@ pub(crate) struct MetaVarExprUnrecognizedVar { pub key: MacroRulesNormalizedIdent, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(expand::var_still_repeating)] pub(crate) struct VarStillRepeating { #[primary_span] @@ -39,7 +39,7 @@ pub(crate) struct VarStillRepeating { pub ident: MacroRulesNormalizedIdent, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(expand::meta_var_dif_seq_matchers)] pub(crate) struct MetaVarsDifSeqMatchers { #[primary_span] diff --git a/compiler/rustc_interface/src/errors.rs b/compiler/rustc_interface/src/errors.rs index dc975099fc7..097640f26c1 100644 --- a/compiler/rustc_interface/src/errors.rs +++ b/compiler/rustc_interface/src/errors.rs @@ -1,10 +1,10 @@ -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use rustc_span::{Span, Symbol}; use std::io; use std::path::Path; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::ferris_identifier)] pub struct FerrisIdentifier { #[primary_span] @@ -13,7 +13,7 @@ pub struct FerrisIdentifier { pub first_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::emoji_identifier)] pub struct EmojiIdentifier { #[primary_span] @@ -21,67 +21,67 @@ pub struct EmojiIdentifier { pub ident: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::mixed_bin_crate)] pub struct MixedBinCrate; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::mixed_proc_macro_crate)] pub struct MixedProcMacroCrate; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::proc_macro_doc_without_arg)] pub struct ProcMacroDocWithoutArg; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::error_writing_dependencies)] pub struct ErrorWritingDependencies<'a> { pub path: &'a Path, pub error: io::Error, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::input_file_would_be_overwritten)] pub struct InputFileWouldBeOverWritten<'a> { pub path: &'a Path, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::generated_file_conflicts_with_directory)] pub struct GeneratedFileConflictsWithDirectory<'a> { pub input_path: &'a Path, pub dir_path: &'a Path, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::temps_dir_error)] pub struct TempsDirError; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::out_dir_error)] pub struct OutDirError; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::cant_emit_mir)] pub struct CantEmitMIR { pub error: io::Error, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::rustc_error_fatal)] pub struct RustcErrorFatal { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::rustc_error_unexpected_annotation)] pub struct RustcErrorUnexpectedAnnotation { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(interface::failed_writing_file)] pub struct FailedWritingFile<'a> { pub path: &'a Path, diff --git a/compiler/rustc_lint/src/errors.rs b/compiler/rustc_lint/src/errors.rs index e5670833898..0c66ce475c4 100644 --- a/compiler/rustc_lint/src/errors.rs +++ b/compiler/rustc_lint/src/errors.rs @@ -1,9 +1,9 @@ use rustc_errors::{fluent, AddToDiagnostic, IntoDiagnostic, ErrorGuaranteed, Handler}; -use rustc_macros::{DiagnosticHandler, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, SessionSubdiagnostic}; use rustc_session::lint::Level; use rustc_span::{Span, Symbol}; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(lint::overruled_attribute, code = "E0453")] pub struct OverruledAttribute { #[primary_span] @@ -42,7 +42,7 @@ impl AddToDiagnostic for OverruledAttributeSub { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(lint::malformed_attribute, code = "E0452")] pub struct MalformedAttribute { #[primary_span] @@ -61,7 +61,7 @@ pub enum MalformedAttributeSub { ReasonMustComeLast(#[primary_span] Span), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(lint::unknown_tool_in_scoped_lint, code = "E0710")] pub struct UnknownToolInScopedLint { #[primary_span] @@ -72,7 +72,7 @@ pub struct UnknownToolInScopedLint { pub is_nightly_build: Option<()>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(lint::builtin_ellipsis_inclusive_range_patterns, code = "E0783")] pub struct BuiltinEllpisisInclusiveRangePatterns { #[primary_span] @@ -107,7 +107,7 @@ impl AddToDiagnostic for RequestedLevel { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(lint::unsupported_group, code = "E0602")] pub struct UnsupportedGroup { pub lint_group: String, @@ -136,7 +136,7 @@ impl IntoDiagnostic<'_> for CheckNameUnknown { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(lint::check_name_unknown_tool, code = "E0602")] pub struct CheckNameUnknownTool { pub tool_name: Symbol, @@ -144,7 +144,7 @@ pub struct CheckNameUnknownTool { pub sub: RequestedLevel, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(lint::check_name_warning)] pub struct CheckNameWarning { pub msg: String, @@ -152,7 +152,7 @@ pub struct CheckNameWarning { pub sub: RequestedLevel, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(lint::check_name_deprecated)] pub struct CheckNameDeprecated { pub lint_name: String, diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs index 47da8ec5da1..36d8ade22ae 100644 --- a/compiler/rustc_lint/src/internal.rs +++ b/compiler/rustc_lint/src/internal.rs @@ -372,7 +372,7 @@ declare_tool_lint! { declare_tool_lint! { pub rustc::DIAGNOSTIC_OUTSIDE_OF_IMPL, Allow, - "prevent creation of diagnostics outside of `DiagnosticHandler`/`AddToDiagnostic` impls", + "prevent creation of diagnostics outside of `IntoDiagnostic`/`AddToDiagnostic` impls", report_in_external_macro: true } @@ -404,7 +404,7 @@ impl LateLintPass<'_> for Diagnostics { let Impl { of_trait: Some(of_trait), .. } = impl_ && let Some(def_id) = of_trait.trait_def_id() && let Some(name) = cx.tcx.get_diagnostic_name(def_id) && - matches!(name, sym::DiagnosticHandler | sym::AddSubdiagnostic | sym::DecorateLint) + matches!(name, sym::Diagnostic | sym::AddSubdiagnostic | sym::DecorateLint) { found_impl = true; break; diff --git a/compiler/rustc_macros/src/diagnostics/diagnostic.rs b/compiler/rustc_macros/src/diagnostics/diagnostic.rs index c5b5edab816..c1aae04fcee 100644 --- a/compiler/rustc_macros/src/diagnostics/diagnostic.rs +++ b/compiler/rustc_macros/src/diagnostics/diagnostic.rs @@ -21,7 +21,7 @@ impl<'a> SessionDiagnosticDerive<'a> { builder: DiagnosticDeriveBuilder { diag, fields: build_field_mapping(&structure), - kind: DiagnosticDeriveKind::DiagnosticHandler, + kind: DiagnosticDeriveKind::Diagnostic, code: None, slug: None, }, @@ -72,7 +72,7 @@ impl<'a> SessionDiagnosticDerive<'a> { } else { span_err( ast.span().unwrap(), - "`#[derive(DiagnosticHandler)]` can only be used on structs", + "`#[derive(Diagnostic)]` can only be used on structs", ) .emit(); diff --git a/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs b/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs index 4af3fd23624..32d6ba62a0d 100644 --- a/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs +++ b/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs @@ -21,12 +21,12 @@ use synstructure::{BindingInfo, Structure}; /// What kind of diagnostic is being derived - a fatal/error/warning or a lint? #[derive(Copy, Clone, PartialEq, Eq)] pub(crate) enum DiagnosticDeriveKind { - DiagnosticHandler, + Diagnostic, LintDiagnostic, } /// Tracks persistent information required for building up individual calls to diagnostic methods -/// for generated diagnostic derives - both `DiagnosticHandler` for fatal/errors/warnings and +/// for generated diagnostic derives - both `Diagnostic` for fatal/errors/warnings and /// `LintDiagnostic` for lints. pub(crate) struct DiagnosticDeriveBuilder { /// The identifier to use for the generated `DiagnosticBuilder` instance. @@ -333,7 +333,7 @@ impl DiagnosticDeriveBuilder { } "primary_span" => { match self.kind { - DiagnosticDeriveKind::DiagnosticHandler => { + DiagnosticDeriveKind::Diagnostic => { report_error_if_not_applied_to_span(attr, &info)?; Ok(quote! { diff --git a/compiler/rustc_macros/src/diagnostics/mod.rs b/compiler/rustc_macros/src/diagnostics/mod.rs index 162089c881e..1d5b32c2556 100644 --- a/compiler/rustc_macros/src/diagnostics/mod.rs +++ b/compiler/rustc_macros/src/diagnostics/mod.rs @@ -12,7 +12,7 @@ use quote::format_ident; use subdiagnostic::SessionSubdiagnosticDerive; use synstructure::Structure; -/// Implements `#[derive(DiagnosticHandler)]`, which allows for errors to be specified as a struct, +/// Implements `#[derive(Diagnostic)]`, which allows for errors to be specified as a struct, /// independent from the actual diagnostics emitting code. /// /// ```ignore (rust) @@ -22,7 +22,7 @@ use synstructure::Structure; /// # use rustc_span::{symbol::Ident, Span}; /// # extern crate rust_middle; /// # use rustc_middle::ty::Ty; -/// #[derive(DiagnosticHandler)] +/// #[derive(Diagnostic)] /// #[diag(borrowck::move_out_of_borrow, code = "E0505")] /// pub struct MoveOutOfBorrowError<'tcx> { /// pub name: Ident, @@ -56,7 +56,7 @@ use synstructure::Structure; /// }); /// ``` /// -/// See rustc dev guide for more examples on using the `#[derive(DiagnosticHandler)]`: +/// See rustc dev guide for more examples on using the `#[derive(Diagnostic)]`: /// pub fn session_diagnostic_derive(s: Structure<'_>) -> TokenStream { SessionDiagnosticDerive::new(format_ident!("diag"), format_ident!("handler"), s).into_tokens() diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs index 13305782ff1..9dd7ccad8bb 100644 --- a/compiler/rustc_macros/src/lib.rs +++ b/compiler/rustc_macros/src/lib.rs @@ -127,7 +127,7 @@ decl_derive!([TypeFoldable, attributes(type_foldable)] => type_foldable::type_fo decl_derive!([TypeVisitable, attributes(type_visitable)] => type_visitable::type_visitable_derive); decl_derive!([Lift, attributes(lift)] => lift::lift_derive); decl_derive!( - [DiagnosticHandler, attributes( + [Diagnostic, attributes( // struct attributes diag, help, diff --git a/compiler/rustc_metadata/src/errors.rs b/compiler/rustc_metadata/src/errors.rs index 0a5973ca1aa..8ff4eb5fdbc 100644 --- a/compiler/rustc_metadata/src/errors.rs +++ b/compiler/rustc_metadata/src/errors.rs @@ -4,48 +4,48 @@ use std::{ }; use rustc_errors::{error_code, IntoDiagnostic, ErrorGuaranteed}; -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use rustc_session::config; use rustc_span::{sym, Span, Symbol}; use rustc_target::spec::{PanicStrategy, TargetTriple}; use crate::locator::CrateFlavor; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::rlib_required)] pub struct RlibRequired { pub crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::lib_required)] pub struct LibRequired<'a> { pub crate_name: Symbol, pub kind: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::crate_dep_multiple)] #[help] pub struct CrateDepMultiple { pub crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::two_panic_runtimes)] pub struct TwoPanicRuntimes { pub prev_name: Symbol, pub cur_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::bad_panic_strategy)] pub struct BadPanicStrategy { pub runtime: Symbol, pub strategy: PanicStrategy, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::required_panic_strategy)] pub struct RequiredPanicStrategy { pub crate_name: Symbol, @@ -53,7 +53,7 @@ pub struct RequiredPanicStrategy { pub desired_strategy: PanicStrategy, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::incompatible_panic_in_drop_strategy)] pub struct IncompatiblePanicInDropStrategy { pub crate_name: Symbol, @@ -61,56 +61,56 @@ pub struct IncompatiblePanicInDropStrategy { pub desired_strategy: PanicStrategy, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::multiple_names_in_link)] pub struct MultipleNamesInLink { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::multiple_kinds_in_link)] pub struct MultipleKindsInLink { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::link_name_form)] pub struct LinkNameForm { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::link_kind_form)] pub struct LinkKindForm { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::link_modifiers_form)] pub struct LinkModifiersForm { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::link_cfg_form)] pub struct LinkCfgForm { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::wasm_import_form)] pub struct WasmImportForm { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::empty_link_name, code = "E0454")] pub struct EmptyLinkName { #[primary_span] @@ -118,21 +118,21 @@ pub struct EmptyLinkName { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::link_framework_apple, code = "E0455")] pub struct LinkFrameworkApple { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::framework_only_windows, code = "E0455")] pub struct FrameworkOnlyWindows { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::unknown_link_kind, code = "E0458")] pub struct UnknownLinkKind<'a> { #[primary_span] @@ -141,49 +141,49 @@ pub struct UnknownLinkKind<'a> { pub kind: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::multiple_link_modifiers)] pub struct MultipleLinkModifiers { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::multiple_cfgs)] pub struct MultipleCfgs { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::link_cfg_single_predicate)] pub struct LinkCfgSinglePredicate { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::multiple_wasm_import)] pub struct MultipleWasmImport { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::unexpected_link_arg)] pub struct UnexpectedLinkArg { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::invalid_link_modifier)] pub struct InvalidLinkModifier { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::multiple_modifiers)] pub struct MultipleModifiers<'a> { #[primary_span] @@ -191,28 +191,28 @@ pub struct MultipleModifiers<'a> { pub modifier: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::bundle_needs_static)] pub struct BundleNeedsStatic { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::whole_archive_needs_static)] pub struct WholeArchiveNeedsStatic { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::as_needed_compatibility)] pub struct AsNeededCompatibility { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::unknown_link_modifier)] pub struct UnknownLinkModifier<'a> { #[primary_span] @@ -220,14 +220,14 @@ pub struct UnknownLinkModifier<'a> { pub modifier: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::incompatible_wasm_link)] pub struct IncompatibleWasmLink { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::link_requires_name, code = "E0459")] pub struct LinkRequiresName { #[primary_span] @@ -235,105 +235,105 @@ pub struct LinkRequiresName { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::raw_dylib_no_nul)] pub struct RawDylibNoNul { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::link_ordinal_raw_dylib)] pub struct LinkOrdinalRawDylib { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::lib_framework_apple)] pub struct LibFrameworkApple; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::empty_renaming_target)] pub struct EmptyRenamingTarget<'a> { pub lib_name: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::renaming_no_link)] pub struct RenamingNoLink<'a> { pub lib_name: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::multiple_renamings)] pub struct MultipleRenamings<'a> { pub lib_name: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::no_link_mod_override)] pub struct NoLinkModOverride { #[primary_span] pub span: Option, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::unsupported_abi_i686)] pub struct UnsupportedAbiI686 { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::unsupported_abi)] pub struct UnsupportedAbi { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::fail_create_file_encoder)] pub struct FailCreateFileEncoder { pub err: Error, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::fail_seek_file)] pub struct FailSeekFile { pub err: Error, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::fail_write_file)] pub struct FailWriteFile { pub err: Error, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::crate_not_panic_runtime)] pub struct CrateNotPanicRuntime { pub crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::no_panic_strategy)] pub struct NoPanicStrategy { pub crate_name: Symbol, pub strategy: PanicStrategy, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::profiler_builtins_needs_core)] pub struct ProfilerBuiltinsNeedsCore; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::not_profiler_runtime)] pub struct NotProfilerRuntime { pub crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::no_multiple_global_alloc)] pub struct NoMultipleGlobalAlloc { #[primary_span] @@ -343,18 +343,18 @@ pub struct NoMultipleGlobalAlloc { pub span1: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::conflicting_global_alloc)] pub struct ConflictingGlobalAlloc { pub crate_name: Symbol, pub other_crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::global_alloc_required)] pub struct GlobalAllocRequired; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::no_transitive_needs_dep)] pub struct NoTransitiveNeedsDep<'a> { pub crate_name: Symbol, @@ -362,39 +362,39 @@ pub struct NoTransitiveNeedsDep<'a> { pub deps_crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::failed_write_error)] pub struct FailedWriteError { pub filename: PathBuf, pub err: Error, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(metadata::missing_native_library)] pub struct MissingNativeLibrary<'a> { pub libname: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(metadata::failed_create_tempdir)] pub struct FailedCreateTempdir { pub err: Error, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::failed_create_file)] pub struct FailedCreateFile<'a> { pub filename: &'a Path, pub err: Error, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::failed_create_encoded_metadata)] pub struct FailedCreateEncodedMetadata { pub err: Error, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::non_ascii_name)] pub struct NonAsciiName { #[primary_span] @@ -402,7 +402,7 @@ pub struct NonAsciiName { pub crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::extern_location_not_exist)] pub struct ExternLocationNotExist<'a> { #[primary_span] @@ -411,7 +411,7 @@ pub struct ExternLocationNotExist<'a> { pub location: &'a Path, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::extern_location_not_file)] pub struct ExternLocationNotFile<'a> { #[primary_span] @@ -444,7 +444,7 @@ impl IntoDiagnostic<'_> for MultipleCandidates { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::multiple_matching_crates, code = "E0464")] #[note] pub struct MultipleMatchingCrates { @@ -454,7 +454,7 @@ pub struct MultipleMatchingCrates { pub candidates: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::symbol_conflicts_current, code = "E0519")] pub struct SymbolConflictsCurrent { #[primary_span] @@ -462,7 +462,7 @@ pub struct SymbolConflictsCurrent { pub crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::symbol_conflicts_others, code = "E0523")] pub struct SymbolConflictsOthers { #[primary_span] @@ -470,7 +470,7 @@ pub struct SymbolConflictsOthers { pub crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::stable_crate_id_collision)] pub struct StableCrateIdCollision { #[primary_span] @@ -479,7 +479,7 @@ pub struct StableCrateIdCollision { pub crate_name1: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::dl_error)] pub struct DlError { #[primary_span] @@ -487,7 +487,7 @@ pub struct DlError { pub err: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::newer_crate_version, code = "E0460")] #[note] #[note(metadata::found_crate_versions)] @@ -499,7 +499,7 @@ pub struct NewerCrateVersion { pub found_crates: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::no_crate_with_triple, code = "E0461")] #[note(metadata::found_crate_versions)] pub struct NoCrateWithTriple<'a> { @@ -511,7 +511,7 @@ pub struct NoCrateWithTriple<'a> { pub found_crates: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::found_staticlib, code = "E0462")] #[note(metadata::found_crate_versions)] #[help] @@ -523,7 +523,7 @@ pub struct FoundStaticlib { pub found_crates: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::incompatible_rustc, code = "E0514")] #[note(metadata::found_crate_versions)] #[help] @@ -617,7 +617,7 @@ impl IntoDiagnostic<'_> for CannotFindCrate { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::no_dylib_plugin, code = "E0457")] pub struct NoDylibPlugin { #[primary_span] @@ -625,7 +625,7 @@ pub struct NoDylibPlugin { pub crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::crate_location_unknown_type)] pub struct CrateLocationUnknownType<'a> { #[primary_span] @@ -633,7 +633,7 @@ pub struct CrateLocationUnknownType<'a> { pub path: &'a Path, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::lib_filename_form)] pub struct LibFilenameForm<'a> { #[primary_span] @@ -642,28 +642,28 @@ pub struct LibFilenameForm<'a> { pub dll_suffix: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::multiple_import_name_type)] pub struct MultipleImportNameType { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::import_name_type_form)] pub struct ImportNameTypeForm { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::import_name_type_x86)] pub struct ImportNameTypeX86 { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::unknown_import_name_type)] pub struct UnknownImportNameType<'a> { #[primary_span] @@ -671,7 +671,7 @@ pub struct UnknownImportNameType<'a> { pub import_name_type: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(metadata::import_name_type_raw)] pub struct ImportNameTypeRaw { #[primary_span] diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs index effda9c0557..6d15feb888a 100644 --- a/compiler/rustc_middle/src/error.rs +++ b/compiler/rustc_middle/src/error.rs @@ -1,9 +1,9 @@ -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use rustc_span::Span; use crate::ty::Ty; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(middle::drop_check_overflow, code = "E0320")] #[note] pub struct DropCheckOverflow<'tcx> { @@ -13,7 +13,7 @@ pub struct DropCheckOverflow<'tcx> { pub overflow_ty: Ty<'tcx>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(middle::opaque_hidden_type_mismatch)] pub struct OpaqueHiddenTypeMismatch<'tcx> { pub self_ty: Ty<'tcx>, @@ -39,7 +39,7 @@ pub enum TypeMismatchReason { }, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(middle::limit_invalid)] pub struct LimitInvalid<'a> { #[primary_span] diff --git a/compiler/rustc_mir_dataflow/src/errors.rs b/compiler/rustc_mir_dataflow/src/errors.rs index 0d36abed2c0..5b1a88cb284 100644 --- a/compiler/rustc_mir_dataflow/src/errors.rs +++ b/compiler/rustc_mir_dataflow/src/errors.rs @@ -1,21 +1,21 @@ -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use rustc_span::{Span, Symbol}; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(mir_dataflow::path_must_end_in_filename)] pub(crate) struct PathMustEndInFilename { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(mir_dataflow::unknown_formatter)] pub(crate) struct UnknownFormatter { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(mir_dataflow::duplicate_values_for)] pub(crate) struct DuplicateValuesFor { #[primary_span] @@ -23,7 +23,7 @@ pub(crate) struct DuplicateValuesFor { pub name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(mir_dataflow::requires_an_argument)] pub(crate) struct RequiresAnArgument { #[primary_span] @@ -31,39 +31,39 @@ pub(crate) struct RequiresAnArgument { pub name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(mir_dataflow::stop_after_dataflow_ended_compilation)] pub(crate) struct StopAfterDataFlowEndedCompilation; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(mir_dataflow::peek_must_be_place_or_ref_place)] pub(crate) struct PeekMustBePlaceOrRefPlace { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(mir_dataflow::peek_must_be_not_temporary)] pub(crate) struct PeekMustBeNotTemporary { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(mir_dataflow::peek_bit_not_set)] pub(crate) struct PeekBitNotSet { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(mir_dataflow::peek_argument_not_a_local)] pub(crate) struct PeekArgumentNotALocal { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(mir_dataflow::peek_argument_untracked)] pub(crate) struct PeekArgumentUntracked { #[primary_span] diff --git a/compiler/rustc_monomorphize/src/errors.rs b/compiler/rustc_monomorphize/src/errors.rs index 150a702dc24..cdc2c74ac8f 100644 --- a/compiler/rustc_monomorphize/src/errors.rs +++ b/compiler/rustc_monomorphize/src/errors.rs @@ -2,10 +2,10 @@ use std::path::PathBuf; use rustc_errors::IntoDiagnostic; use rustc_errors::ErrorGuaranteed; -use rustc_macros::{DiagnosticHandler, LintDiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic}; use rustc_span::Span; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(monomorphize::recursion_limit)] pub struct RecursionLimit { #[primary_span] @@ -19,7 +19,7 @@ pub struct RecursionLimit { pub path: PathBuf, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(monomorphize::type_length_limit)] #[help(monomorphize::consider_type_length_limit)] pub struct TypeLengthLimit { @@ -32,7 +32,7 @@ pub struct TypeLengthLimit { pub type_length: usize, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(monomorphize::requires_lang_item)] pub struct RequiresLangItem { pub lang_item: String, @@ -72,11 +72,11 @@ pub struct LargeAssignmentsLint { pub limit: u64, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(monomorphize::unknown_partition_strategy)] pub struct UnknownPartitionStrategy; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(monomorphize::symbol_already_defined)] pub struct SymbolAlreadyDefined { #[primary_span] diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs index 02148193cf0..9989ebb7cdf 100644 --- a/compiler/rustc_parse/src/parser/diagnostics.rs +++ b/compiler/rustc_parse/src/parser/diagnostics.rs @@ -20,7 +20,7 @@ use rustc_errors::{ fluent, Applicability, DiagnosticBuilder, DiagnosticMessage, Handler, MultiSpan, PResult, }; use rustc_errors::{pluralize, struct_span_err, Diagnostic, ErrorGuaranteed}; -use rustc_macros::{DiagnosticHandler, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, SessionSubdiagnostic}; use rustc_span::source_map::Spanned; use rustc_span::symbol::{kw, sym, Ident}; use rustc_span::{Span, SpanSnippetError, DUMMY_SP}; @@ -242,7 +242,7 @@ impl MultiSugg { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::maybe_report_ambiguous_plus)] struct AmbiguousPlus { pub sum_ty: String, @@ -251,7 +251,7 @@ struct AmbiguousPlus { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::maybe_recover_from_bad_type_plus, code = "E0178")] struct BadTypePlus { pub ty: String, @@ -285,7 +285,7 @@ pub enum BadTypePlusSub { }, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::maybe_recover_from_bad_qpath_stage_2)] struct BadQPathStage2 { #[primary_span] @@ -294,7 +294,7 @@ struct BadQPathStage2 { ty: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::incorrect_semicolon)] struct IncorrectSemicolon<'a> { #[primary_span] @@ -305,7 +305,7 @@ struct IncorrectSemicolon<'a> { name: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::incorrect_use_of_await)] struct IncorrectUseOfAwait { #[primary_span] @@ -313,7 +313,7 @@ struct IncorrectUseOfAwait { span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::incorrect_use_of_await)] struct IncorrectAwait { #[primary_span] @@ -324,7 +324,7 @@ struct IncorrectAwait { question_mark: &'static str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::in_in_typo)] struct InInTypo { #[primary_span] @@ -333,7 +333,7 @@ struct InInTypo { sugg_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::invalid_variable_declaration)] pub struct InvalidVariableDeclaration { #[primary_span] @@ -362,7 +362,7 @@ pub enum InvalidVariableDeclarationSub { UseLetNotVar(#[primary_span] Span), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::invalid_comparison_operator)] pub(crate) struct InvalidComparisonOperator { #[primary_span] @@ -389,7 +389,7 @@ pub(crate) enum InvalidComparisonOperatorSub { Spaceship(#[primary_span] Span), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::invalid_logical_operator)] #[note] pub(crate) struct InvalidLogicalOperator { @@ -416,7 +416,7 @@ pub(crate) enum InvalidLogicalOperatorSub { Disjunction(#[primary_span] Span), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::tilde_is_not_unary_operator)] pub(crate) struct TildeAsUnaryOperator( #[primary_span] @@ -424,7 +424,7 @@ pub(crate) struct TildeAsUnaryOperator( pub Span, ); -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::unexpected_token_after_not)] pub(crate) struct NotAsNegationOperator { #[primary_span] @@ -458,7 +458,7 @@ pub enum NotAsNegationOperatorSub { SuggestNotLogical(#[primary_span] Span), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::malformed_loop_label)] pub(crate) struct MalformedLoopLabel { #[primary_span] @@ -467,7 +467,7 @@ pub(crate) struct MalformedLoopLabel { pub correct_label: Ident, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::lifetime_in_borrow_expression)] pub(crate) struct LifetimeInBorrowExpression { #[primary_span] @@ -477,15 +477,15 @@ pub(crate) struct LifetimeInBorrowExpression { pub lifetime_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::field_expression_with_generic)] pub(crate) struct FieldExpressionWithGeneric(#[primary_span] pub Span); -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::macro_invocation_with_qualified_path)] pub(crate) struct MacroInvocationWithQualifiedPath(#[primary_span] pub Span); -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::unexpected_token_after_label)] pub(crate) struct UnexpectedTokenAfterLabel( #[primary_span] @@ -493,7 +493,7 @@ pub(crate) struct UnexpectedTokenAfterLabel( pub Span, ); -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::require_colon_after_labeled_expression)] #[note] pub(crate) struct RequireColonAfterLabeledExpression { @@ -505,7 +505,7 @@ pub(crate) struct RequireColonAfterLabeledExpression { pub label_end: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::do_catch_syntax_removed)] #[note] pub(crate) struct DoCatchSyntaxRemoved { @@ -514,7 +514,7 @@ pub(crate) struct DoCatchSyntaxRemoved { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::float_literal_requires_integer_part)] pub(crate) struct FloatLiteralRequiresIntegerPart { #[primary_span] @@ -523,7 +523,7 @@ pub(crate) struct FloatLiteralRequiresIntegerPart { pub correct: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::invalid_int_literal_width)] #[help] pub(crate) struct InvalidIntLiteralWidth { @@ -532,7 +532,7 @@ pub(crate) struct InvalidIntLiteralWidth { pub width: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::invalid_num_literal_base_prefix)] #[note] pub(crate) struct InvalidNumLiteralBasePrefix { @@ -542,7 +542,7 @@ pub(crate) struct InvalidNumLiteralBasePrefix { pub fixed: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::invalid_num_literal_suffix)] #[help] pub(crate) struct InvalidNumLiteralSuffix { @@ -552,7 +552,7 @@ pub(crate) struct InvalidNumLiteralSuffix { pub suffix: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::invalid_float_literal_width)] #[help] pub(crate) struct InvalidFloatLiteralWidth { @@ -561,7 +561,7 @@ pub(crate) struct InvalidFloatLiteralWidth { pub width: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::invalid_float_literal_suffix)] #[help] pub(crate) struct InvalidFloatLiteralSuffix { @@ -571,14 +571,14 @@ pub(crate) struct InvalidFloatLiteralSuffix { pub suffix: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::int_literal_too_large)] pub(crate) struct IntLiteralTooLarge { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::missing_semicolon_before_array)] pub(crate) struct MissingSemicolonBeforeArray { #[primary_span] @@ -587,7 +587,7 @@ pub(crate) struct MissingSemicolonBeforeArray { pub semicolon: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::invalid_block_macro_segment)] pub(crate) struct InvalidBlockMacroSegment { #[primary_span] @@ -596,7 +596,7 @@ pub(crate) struct InvalidBlockMacroSegment { pub context: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::if_expression_missing_then_block)] pub(crate) struct IfExpressionMissingThenBlock { #[primary_span] @@ -613,7 +613,7 @@ pub(crate) enum IfExpressionMissingThenBlockSub { AddThenBlock(#[primary_span] Span), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::if_expression_missing_condition)] pub(crate) struct IfExpressionMissingCondition { #[primary_span] @@ -623,14 +623,14 @@ pub(crate) struct IfExpressionMissingCondition { pub block_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::expected_expression_found_let)] pub(crate) struct ExpectedExpressionFoundLet { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::expected_else_block)] pub(crate) struct ExpectedElseBlock { #[primary_span] @@ -642,7 +642,7 @@ pub(crate) struct ExpectedElseBlock { pub condition_start: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::outer_attribute_not_allowed_on_if_else)] pub(crate) struct OuterAttributeNotAllowedOnIfElse { #[primary_span] @@ -659,7 +659,7 @@ pub(crate) struct OuterAttributeNotAllowedOnIfElse { pub attributes: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::missing_in_in_for_loop)] pub(crate) struct MissingInInForLoop { #[primary_span] @@ -677,7 +677,7 @@ pub(crate) enum MissingInInForLoopSub { AddIn(#[primary_span] Span), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::missing_comma_after_match_arm)] pub(crate) struct MissingCommaAfterMatchArm { #[primary_span] @@ -685,7 +685,7 @@ pub(crate) struct MissingCommaAfterMatchArm { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::catch_after_try)] #[help] pub(crate) struct CatchAfterTry { @@ -693,7 +693,7 @@ pub(crate) struct CatchAfterTry { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::comma_after_base_struct)] #[note] pub(crate) struct CommaAfterBaseStruct { @@ -703,7 +703,7 @@ pub(crate) struct CommaAfterBaseStruct { pub comma: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::eq_field_init)] pub(crate) struct EqFieldInit { #[primary_span] @@ -712,7 +712,7 @@ pub(crate) struct EqFieldInit { pub eq: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::dotdotdot)] pub(crate) struct DotDotDot { #[primary_span] @@ -721,7 +721,7 @@ pub(crate) struct DotDotDot { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::left_arrow_operator)] pub(crate) struct LeftArrowOperator { #[primary_span] @@ -729,7 +729,7 @@ pub(crate) struct LeftArrowOperator { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::remove_let)] pub(crate) struct RemoveLet { #[primary_span] diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs index ade5927be8e..bff2978bd13 100644 --- a/compiler/rustc_passes/src/errors.rs +++ b/compiler/rustc_passes/src/errors.rs @@ -1,5 +1,5 @@ use rustc_errors::{Applicability, MultiSpan}; -use rustc_macros::{DiagnosticHandler, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic, SessionSubdiagnostic}; use rustc_span::{Span, Symbol}; #[derive(LintDiagnostic)] @@ -32,7 +32,7 @@ pub struct IgnoredInlineAttrFnProto; #[note] pub struct IgnoredInlineAttrConstants; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::inline_not_fn_or_closure, code = "E0518")] pub struct InlineNotFnOrClosure { #[primary_span] @@ -53,7 +53,7 @@ pub struct IgnoredNoCoveragePropagate; #[diag(passes::no_coverage_fn_defn)] pub struct IgnoredNoCoverageFnDefn; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::no_coverage_not_coverable, code = "E0788")] pub struct IgnoredNoCoverageNotCoverable { #[primary_span] @@ -62,7 +62,7 @@ pub struct IgnoredNoCoverageNotCoverable { pub defn_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::should_be_applied_to_fn)] pub struct AttrShouldBeAppliedToFn { #[primary_span] @@ -71,14 +71,14 @@ pub struct AttrShouldBeAppliedToFn { pub defn_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::naked_tracked_caller, code = "E0736")] pub struct NakedTrackedCaller { #[primary_span] pub attr_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::should_be_applied_to_fn, code = "E0739")] pub struct TrackedCallerWrongLocation { #[primary_span] @@ -87,7 +87,7 @@ pub struct TrackedCallerWrongLocation { pub defn_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::should_be_applied_to_struct_enum, code = "E0701")] pub struct NonExhaustiveWrongLocation { #[primary_span] @@ -96,7 +96,7 @@ pub struct NonExhaustiveWrongLocation { pub defn_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::should_be_applied_to_trait)] pub struct AttrShouldBeAppliedToTrait { #[primary_span] @@ -109,7 +109,7 @@ pub struct AttrShouldBeAppliedToTrait { #[diag(passes::target_feature_on_statement)] pub struct TargetFeatureOnStatement; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::should_be_applied_to_static)] pub struct AttrShouldBeAppliedToStatic { #[primary_span] @@ -118,7 +118,7 @@ pub struct AttrShouldBeAppliedToStatic { pub defn_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_expect_str)] pub struct DocExpectStr<'a> { #[primary_span] @@ -126,7 +126,7 @@ pub struct DocExpectStr<'a> { pub attr_name: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_alias_empty)] pub struct DocAliasEmpty<'a> { #[primary_span] @@ -134,7 +134,7 @@ pub struct DocAliasEmpty<'a> { pub attr_str: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_alias_bad_char)] pub struct DocAliasBadChar<'a> { #[primary_span] @@ -143,7 +143,7 @@ pub struct DocAliasBadChar<'a> { pub char_: char, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_alias_start_end)] pub struct DocAliasStartEnd<'a> { #[primary_span] @@ -151,7 +151,7 @@ pub struct DocAliasStartEnd<'a> { pub attr_str: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_alias_bad_location)] pub struct DocAliasBadLocation<'a> { #[primary_span] @@ -160,7 +160,7 @@ pub struct DocAliasBadLocation<'a> { pub location: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_alias_not_an_alias)] pub struct DocAliasNotAnAlias<'a> { #[primary_span] @@ -175,35 +175,35 @@ pub struct DocAliasDuplicated { pub first_defn: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_alias_not_string_literal)] pub struct DocAliasNotStringLiteral { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_alias_malformed)] pub struct DocAliasMalformed { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_keyword_empty_mod)] pub struct DocKeywordEmptyMod { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_keyword_not_mod)] pub struct DocKeywordNotMod { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_keyword_invalid_ident)] pub struct DocKeywordInvalidIdent { #[primary_span] @@ -211,21 +211,21 @@ pub struct DocKeywordInvalidIdent { pub doc_keyword: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_fake_variadic_not_valid)] pub struct DocFakeVariadicNotValid { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_keyword_only_impl)] pub struct DocKeywordOnlyImpl { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_inline_conflict)] #[help] pub struct DocKeywordConflict { @@ -243,7 +243,7 @@ pub struct DocInlineOnlyUse { pub item_span: Option, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::doc_attr_not_crate_level)] pub struct DocAttrNotCrateLevel<'a> { #[primary_span] @@ -295,7 +295,7 @@ pub struct DocTestUnknownInclude { #[diag(passes::doc_invalid)] pub struct DocInvalid; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::pass_by_value)] pub struct PassByValue { #[primary_span] @@ -304,7 +304,7 @@ pub struct PassByValue { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::allow_incoherent_impl)] pub struct AllowIncoherentImpl { #[primary_span] @@ -313,7 +313,7 @@ pub struct AllowIncoherentImpl { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::has_incoherent_inherent_impl)] pub struct HasIncoherentInherentImpl { #[primary_span] @@ -336,7 +336,7 @@ pub struct MustUseNoEffect { pub target: rustc_hir::Target, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::must_not_suspend)] pub struct MustNotSuspend { #[primary_span] @@ -372,7 +372,7 @@ pub struct LinkName<'a> { pub value: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::no_link)] pub struct NoLink { #[primary_span] @@ -381,7 +381,7 @@ pub struct NoLink { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::export_name)] pub struct ExportName { #[primary_span] @@ -390,7 +390,7 @@ pub struct ExportName { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_layout_scalar_valid_range_not_struct)] pub struct RustcLayoutScalarValidRangeNotStruct { #[primary_span] @@ -399,14 +399,14 @@ pub struct RustcLayoutScalarValidRangeNotStruct { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_layout_scalar_valid_range_arg)] pub struct RustcLayoutScalarValidRangeArg { #[primary_span] pub attr_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_legacy_const_generics_only)] pub struct RustcLegacyConstGenericsOnly { #[primary_span] @@ -415,7 +415,7 @@ pub struct RustcLegacyConstGenericsOnly { pub param_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_legacy_const_generics_index)] pub struct RustcLegacyConstGenericsIndex { #[primary_span] @@ -424,7 +424,7 @@ pub struct RustcLegacyConstGenericsIndex { pub generics_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_legacy_const_generics_index_exceed)] pub struct RustcLegacyConstGenericsIndexExceed { #[primary_span] @@ -433,14 +433,14 @@ pub struct RustcLegacyConstGenericsIndexExceed { pub arg_count: usize, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_legacy_const_generics_index_negative)] pub struct RustcLegacyConstGenericsIndexNegative { #[primary_span] pub invalid_args: Vec, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_dirty_clean)] pub struct RustcDirtyClean { #[primary_span] @@ -475,7 +475,7 @@ pub struct NoMangle { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::repr_ident, code = "E0565")] pub struct ReprIdent { #[primary_span] @@ -486,21 +486,21 @@ pub struct ReprIdent { #[diag(passes::repr_conflicting, code = "E0566")] pub struct ReprConflicting; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::used_static)] pub struct UsedStatic { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::used_compiler_linker)] pub struct UsedCompilerLinker { #[primary_span] pub spans: Vec, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::allow_internal_unstable)] pub struct AllowInternalUnstable { #[primary_span] @@ -509,14 +509,14 @@ pub struct AllowInternalUnstable { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::debug_visualizer_placement)] pub struct DebugVisualizerPlacement { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::debug_visualizer_invalid)] #[note(passes::note_1)] #[note(passes::note_2)] @@ -526,7 +526,7 @@ pub struct DebugVisualizerInvalid { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_allow_const_fn_unstable)] pub struct RustcAllowConstFnUnstable { #[primary_span] @@ -535,7 +535,7 @@ pub struct RustcAllowConstFnUnstable { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_std_internal_symbol)] pub struct RustcStdInternalSymbol { #[primary_span] @@ -544,21 +544,21 @@ pub struct RustcStdInternalSymbol { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::const_trait)] pub struct ConstTrait { #[primary_span] pub attr_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::link_ordinal)] pub struct LinkOrdinal { #[primary_span] pub attr_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::stability_promotable)] pub struct StabilityPromotable { #[primary_span] @@ -602,7 +602,7 @@ pub struct Unused { pub note: UnusedNote, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::non_exported_macro_invalid_attrs, code = "E0518")] pub struct NonExportedMacroInvalidAttrs { #[primary_span] @@ -621,7 +621,7 @@ pub struct UnusedDuplicate { pub warning: Option<()>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::unused_multiple)] pub struct UnusedMultiple { #[primary_span] @@ -632,7 +632,7 @@ pub struct UnusedMultiple { pub name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_lint_opt_ty)] pub struct RustcLintOptTy { #[primary_span] @@ -641,7 +641,7 @@ pub struct RustcLintOptTy { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(passes::rustc_lint_opt_deny_field_access)] pub struct RustcLintOptDenyFieldAccess { #[primary_span] diff --git a/compiler/rustc_plugin_impl/src/errors.rs b/compiler/rustc_plugin_impl/src/errors.rs index 0b2c09f9e1d..07ce92a9b26 100644 --- a/compiler/rustc_plugin_impl/src/errors.rs +++ b/compiler/rustc_plugin_impl/src/errors.rs @@ -1,9 +1,9 @@ //! Errors emitted by plugin_impl -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use rustc_span::Span; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(plugin_impl::load_plugin_error)] pub struct LoadPluginError { #[primary_span] @@ -11,7 +11,7 @@ pub struct LoadPluginError { pub msg: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(plugin_impl::malformed_plugin_attribute, code = "E0498")] pub struct MalformedPluginAttribute { #[primary_span] diff --git a/compiler/rustc_privacy/src/errors.rs b/compiler/rustc_privacy/src/errors.rs index 56a2cb059b5..71552119482 100644 --- a/compiler/rustc_privacy/src/errors.rs +++ b/compiler/rustc_privacy/src/errors.rs @@ -1,8 +1,8 @@ use rustc_errors::DiagnosticArgFromDisplay; -use rustc_macros::{DiagnosticHandler, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic, SessionSubdiagnostic}; use rustc_span::{Span, Symbol}; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(privacy::field_is_private, code = "E0451")] pub struct FieldIsPrivate { #[primary_span] @@ -29,7 +29,7 @@ pub enum FieldIsPrivateLabel { }, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(privacy::item_is_private)] pub struct ItemIsPrivate<'a> { #[primary_span] @@ -39,7 +39,7 @@ pub struct ItemIsPrivate<'a> { pub descr: DiagnosticArgFromDisplay<'a>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(privacy::unnamed_item_is_private)] pub struct UnnamedItemIsPrivate { #[primary_span] @@ -48,7 +48,7 @@ pub struct UnnamedItemIsPrivate { } // Duplicate of `InPublicInterface` but with a different error code, shares the same slug. -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(privacy::in_public_interface, code = "E0445")] pub struct InPublicInterfaceTraits<'a> { #[primary_span] @@ -62,7 +62,7 @@ pub struct InPublicInterfaceTraits<'a> { } // Duplicate of `InPublicInterfaceTraits` but with a different error code, shares the same slug. -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(privacy::in_public_interface, code = "E0446")] pub struct InPublicInterface<'a> { #[primary_span] diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs index 97a74517f68..4c770152f12 100644 --- a/compiler/rustc_query_system/src/error.rs +++ b/compiler/rustc_query_system/src/error.rs @@ -46,7 +46,7 @@ pub struct CycleUsage { pub usage: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(query_system::cycle, code = "E0391")] pub struct Cycle { #[primary_span] @@ -62,11 +62,11 @@ pub struct Cycle { pub cycle_usage: Option, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(query_system::reentrant)] pub struct Reentrant; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(query_system::increment_compilation)] #[help] #[note(query_system::increment_compilation_note1)] diff --git a/compiler/rustc_save_analysis/src/errors.rs b/compiler/rustc_save_analysis/src/errors.rs index 0983ec2f6f7..8a15ba63661 100644 --- a/compiler/rustc_save_analysis/src/errors.rs +++ b/compiler/rustc_save_analysis/src/errors.rs @@ -1,8 +1,8 @@ -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use std::path::Path; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(save_analysis::could_not_open)] pub(crate) struct CouldNotOpen<'a> { pub file_name: &'a Path, diff --git a/compiler/rustc_session/src/errors.rs b/compiler/rustc_session/src/errors.rs index 4cf46109895..7ffe757463f 100644 --- a/compiler/rustc_session/src/errors.rs +++ b/compiler/rustc_session/src/errors.rs @@ -8,7 +8,7 @@ use rustc_span::{Span, Symbol}; use rustc_target::abi::TargetDataLayoutErrors; use rustc_target::spec::{SplitDebuginfo, StackProtector, TargetTriple}; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(session::incorrect_cgu_reuse_type)] pub struct IncorrectCguReuseType<'a> { #[primary_span] @@ -19,14 +19,14 @@ pub struct IncorrectCguReuseType<'a> { pub at_least: u8, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(session::cgu_not_recorded)] pub struct CguNotRecorded<'a> { pub cgu_user_name: &'a str, pub cgu_name: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(session::feature_gate_error, code = "E0658")] pub struct FeatureGateError<'a> { #[primary_span] @@ -46,7 +46,7 @@ pub struct FeatureDiagnosticHelp { pub feature: Symbol, } -impl DiagnosticHandler<'_, !> for TargetDataLayoutErrors<'_> { +impl IntoDiagnostic<'_, !> for TargetDataLayoutErrors<'_> { fn into_diagnostic(self, handler: &Handler) -> DiagnosticBuilder<'_, !> { let mut diag; match self { diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 98ff9694808..ea69334616b 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -177,7 +177,7 @@ symbols! { DecorateLint, Default, Deref, - DiagnosticHandler, + Diagnostic, DiagnosticMessage, DirBuilder, Display, diff --git a/compiler/rustc_trait_selection/src/errors.rs b/compiler/rustc_trait_selection/src/errors.rs index f62bdb00ee0..b02ee593cbe 100644 --- a/compiler/rustc_trait_selection/src/errors.rs +++ b/compiler/rustc_trait_selection/src/errors.rs @@ -1,10 +1,10 @@ use rustc_errors::{fluent, IntoDiagnostic, ErrorGuaranteed, Handler}; -use rustc_macros::DiagnosticHandler; +use rustc_macros::Diagnostic; use rustc_middle::ty::{PolyTraitRef, Ty, Unevaluated}; use rustc_session::Limit; use rustc_span::{Span, Symbol}; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(trait_selection::dump_vtable_entries)] pub struct DumpVTableEntries<'a> { #[primary_span] @@ -13,7 +13,7 @@ pub struct DumpVTableEntries<'a> { pub entries: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(trait_selection::unable_to_construct_constant_value)] pub struct UnableToConstructConstantValue<'a> { #[primary_span] @@ -21,7 +21,7 @@ pub struct UnableToConstructConstantValue<'a> { pub unevaluated: Unevaluated<'a>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[help] #[diag(trait_selection::auto_deref_reached_recursion_limit, code = "E0055")] pub struct AutoDerefReachedRecursionLimit<'a> { @@ -33,7 +33,7 @@ pub struct AutoDerefReachedRecursionLimit<'a> { pub crate_name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(trait_selection::empty_on_clause_in_rustc_on_unimplemented, code = "E0232")] pub struct EmptyOnClauseInOnUnimplemented { #[primary_span] @@ -41,7 +41,7 @@ pub struct EmptyOnClauseInOnUnimplemented { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(trait_selection::invalid_on_clause_in_rustc_on_unimplemented, code = "E0232")] pub struct InvalidOnClauseInOnUnimplemented { #[primary_span] @@ -49,7 +49,7 @@ pub struct InvalidOnClauseInOnUnimplemented { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(trait_selection::no_value_in_rustc_on_unimplemented, code = "E0232")] #[note] pub struct NoValueInOnUnimplemented { diff --git a/compiler/rustc_ty_utils/src/errors.rs b/compiler/rustc_ty_utils/src/errors.rs index 995e87bcd3b..85165187310 100644 --- a/compiler/rustc_ty_utils/src/errors.rs +++ b/compiler/rustc_ty_utils/src/errors.rs @@ -1,16 +1,16 @@ //! Errors emitted by ty_utils -use rustc_macros::{DiagnosticHandler, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, SessionSubdiagnostic}; use rustc_middle::ty::Ty; use rustc_span::Span; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(ty_utils::needs_drop_overflow)] pub struct NeedsDropOverflow<'tcx> { pub query_ty: Ty<'tcx>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(ty_utils::generic_constant_too_complex)] #[help] pub struct GenericConstantTooComplex { diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs index 11661b8ef6c..23fadff3248 100644 --- a/compiler/rustc_typeck/src/check/expr.rs +++ b/compiler/rustc_typeck/src/check/expr.rs @@ -881,7 +881,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { return; } - // FIXME: Make this use DiagnosticHandler once error codes can be dynamically set. + // FIXME: Make this use Diagnostic once error codes can be dynamically set. let mut err = self.tcx.sess.struct_span_err_with_code( op_span, "invalid left-hand side of assignment", diff --git a/compiler/rustc_typeck/src/errors.rs b/compiler/rustc_typeck/src/errors.rs index 50d400e2921..6f00591d54e 100644 --- a/compiler/rustc_typeck/src/errors.rs +++ b/compiler/rustc_typeck/src/errors.rs @@ -1,11 +1,11 @@ //! Errors emitted by typeck. use rustc_errors::IntoDiagnostic; use rustc_errors::{error_code, Applicability, DiagnosticBuilder, ErrorGuaranteed, Handler}; -use rustc_macros::{DiagnosticHandler, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic, SessionSubdiagnostic}; use rustc_middle::ty::Ty; use rustc_span::{symbol::Ident, Span, Symbol}; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::field_multiply_specified_in_initializer, code = "E0062")] pub struct FieldMultiplySpecifiedInInitializer { #[primary_span] @@ -16,7 +16,7 @@ pub struct FieldMultiplySpecifiedInInitializer { pub ident: Ident, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::unrecognized_atomic_operation, code = "E0092")] pub struct UnrecognizedAtomicOperation<'a> { #[primary_span] @@ -25,7 +25,7 @@ pub struct UnrecognizedAtomicOperation<'a> { pub op: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::wrong_number_of_generic_arguments_to_intrinsic, code = "E0094")] pub struct WrongNumberOfGenericArgumentsToIntrinsic<'a> { #[primary_span] @@ -36,7 +36,7 @@ pub struct WrongNumberOfGenericArgumentsToIntrinsic<'a> { pub descr: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::unrecognized_intrinsic_function, code = "E0093")] pub struct UnrecognizedIntrinsicFunction { #[primary_span] @@ -45,7 +45,7 @@ pub struct UnrecognizedIntrinsicFunction { pub name: Symbol, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::lifetimes_or_bounds_mismatch_on_trait, code = "E0195")] pub struct LifetimesOrBoundsMismatchOnTrait { #[primary_span] @@ -57,7 +57,7 @@ pub struct LifetimesOrBoundsMismatchOnTrait { pub ident: Ident, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::drop_impl_on_wrong_item, code = "E0120")] pub struct DropImplOnWrongItem { #[primary_span] @@ -65,7 +65,7 @@ pub struct DropImplOnWrongItem { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::field_already_declared, code = "E0124")] pub struct FieldAlreadyDeclared { pub field_name: Ident, @@ -76,7 +76,7 @@ pub struct FieldAlreadyDeclared { pub prev_span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::copy_impl_on_type_with_dtor, code = "E0184")] pub struct CopyImplOnTypeWithDtor { #[primary_span] @@ -84,14 +84,14 @@ pub struct CopyImplOnTypeWithDtor { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::multiple_relaxed_default_bounds, code = "E0203")] pub struct MultipleRelaxedDefaultBounds { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::copy_impl_on_non_adt, code = "E0206")] pub struct CopyImplOnNonAdt { #[primary_span] @@ -99,7 +99,7 @@ pub struct CopyImplOnNonAdt { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::trait_object_declared_with_no_traits, code = "E0224")] pub struct TraitObjectDeclaredWithNoTraits { #[primary_span] @@ -108,14 +108,14 @@ pub struct TraitObjectDeclaredWithNoTraits { pub trait_alias_span: Option, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0227")] pub struct AmbiguousLifetimeBound { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::assoc_type_binding_not_allowed, code = "E0229")] pub struct AssocTypeBindingNotAllowed { #[primary_span] @@ -123,14 +123,14 @@ pub struct AssocTypeBindingNotAllowed { pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::functional_record_update_on_non_struct, code = "E0436")] pub struct FunctionalRecordUpdateOnNonStruct { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::typeof_reserved_keyword_used, code = "E0516")] pub struct TypeofReservedKeywordUsed<'tcx> { pub ty: Ty<'tcx>, @@ -141,7 +141,7 @@ pub struct TypeofReservedKeywordUsed<'tcx> { pub opt_sugg: Option<(Span, Applicability)>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::return_stmt_outside_of_fn_body, code = "E0572")] pub struct ReturnStmtOutsideOfFnBody { #[primary_span] @@ -152,14 +152,14 @@ pub struct ReturnStmtOutsideOfFnBody { pub encl_fn_span: Option, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::yield_expr_outside_of_generator, code = "E0627")] pub struct YieldExprOutsideOfGenerator { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::struct_expr_non_exhaustive, code = "E0639")] pub struct StructExprNonExhaustive { #[primary_span] @@ -167,14 +167,14 @@ pub struct StructExprNonExhaustive { pub what: &'static str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::method_call_on_unknown_type, code = "E0699")] pub struct MethodCallOnUnknownType { #[primary_span] pub span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::value_of_associated_struct_already_specified, code = "E0719")] pub struct ValueOfAssociatedStructAlreadySpecified { #[primary_span] @@ -186,7 +186,7 @@ pub struct ValueOfAssociatedStructAlreadySpecified { pub def_path: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::address_of_temporary_taken, code = "E0745")] pub struct AddressOfTemporaryTaken { #[primary_span] @@ -232,7 +232,7 @@ pub enum ExpectedReturnTypeLabel<'tcx> { }, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::unconstrained_opaque_type)] #[note] pub struct UnconstrainedOpaqueType { @@ -249,7 +249,7 @@ pub struct MissingTypeParams { pub empty_generic_args: bool, } -// Manual implementation of `DiagnosticHandler` to be able to call `span_to_snippet`. +// Manual implementation of `IntoDiagnostic` to be able to call `span_to_snippet`. impl<'a> IntoDiagnostic<'a> for MissingTypeParams { fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> { let mut err = handler.struct_span_err_with_code( @@ -306,7 +306,7 @@ impl<'a> IntoDiagnostic<'a> for MissingTypeParams { } } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::manual_implementation, code = "E0183")] #[help] pub struct ManualImplementation { @@ -316,7 +316,7 @@ pub struct ManualImplementation { pub trait_name: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::substs_on_overridden_impl)] pub struct SubstsOnOverriddenImpl { #[primary_span] @@ -339,7 +339,7 @@ pub struct ExternCrateNotIdiomatic { pub suggestion_code: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::expected_used_symbol)] pub struct ExpectedUsedSymbol { #[primary_span] diff --git a/src/test/ui-fulldeps/internal-lints/diagnostics.rs b/src/test/ui-fulldeps/internal-lints/diagnostics.rs index e95ab048db3..93766de9a91 100644 --- a/src/test/ui-fulldeps/internal-lints/diagnostics.rs +++ b/src/test/ui-fulldeps/internal-lints/diagnostics.rs @@ -15,10 +15,10 @@ use rustc_errors::{ AddToDiagnostic, IntoDiagnostic, Diagnostic, DiagnosticBuilder, ErrorGuaranteed, Handler, fluent }; -use rustc_macros::{DiagnosticHandler, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, SessionSubdiagnostic}; use rustc_span::Span; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(parser::expect_path)] struct DeriveSessionDiagnostic { #[primary_span] diff --git a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs index 32ba5be8963..fd8128c31f8 100644 --- a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs +++ b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs @@ -1,10 +1,10 @@ // check-fail -// Tests error conditions for specifying diagnostics using #[derive(DiagnosticHandler)] +// Tests error conditions for specifying diagnostics using #[derive(Diagnostic)] // normalize-stderr-test "the following other types implement trait `IntoDiagnosticArg`:(?:.*\n){0,9}\s+and \d+ others" -> "normalized in stderr" // normalize-stderr-test "diagnostic_builder\.rs:[0-9]+:[0-9]+" -> "diagnostic_builder.rs:LL:CC" // The proc_macro2 crate handles spans differently when on beta/stable release rather than nightly, -// changing the output of this test. Since DiagnosticHandler is strictly internal to the compiler +// changing the output of this test. Since Diagnostic is strictly internal to the compiler // the test is just ignored on stable and beta: // ignore-beta // ignore-stable @@ -17,7 +17,7 @@ use rustc_span::symbol::Ident; use rustc_span::Span; extern crate rustc_macros; -use rustc_macros::{DiagnosticHandler, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic, SessionSubdiagnostic}; extern crate rustc_middle; use rustc_middle::ty::Ty; @@ -27,70 +27,70 @@ use rustc_errors::{Applicability, MultiSpan}; extern crate rustc_session; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct Hello {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct HelloWarn {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] -//~^ ERROR `#[derive(DiagnosticHandler)]` can only be used on structs -enum DiagnosticHandlerOnEnum { +//~^ ERROR `#[derive(Diagnostic)]` can only be used on structs +enum DiagnosticOnEnum { Foo, Bar, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[diag = "E0123"] //~^ ERROR `#[diag = ...]` is not a valid attribute struct WrongStructAttrStyle {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[nonsense(typeck::ambiguous_lifetime_bound, code = "E0123")] //~^ ERROR `#[nonsense(...)]` is not a valid attribute //~^^ ERROR diagnostic slug not specified //~^^^ ERROR cannot find attribute `nonsense` in this scope struct InvalidStructAttr {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag("E0123")] //~^ ERROR `#[diag("...")]` is not a valid attribute //~^^ ERROR diagnostic slug not specified struct InvalidLitNestedAttr {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(nonsense, code = "E0123")] //~^ ERROR cannot find value `nonsense` in module `rustc_errors::fluent` struct InvalidNestedStructAttr {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(nonsense("foo"), code = "E0123", slug = "foo")] //~^ ERROR `#[diag(nonsense(...))]` is not a valid attribute //~^^ ERROR diagnostic slug not specified struct InvalidNestedStructAttr1 {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(nonsense = "...", code = "E0123", slug = "foo")] //~^ ERROR `#[diag(nonsense = ...)]` is not a valid attribute //~^^ ERROR diagnostic slug not specified struct InvalidNestedStructAttr2 {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(nonsense = 4, code = "E0123", slug = "foo")] //~^ ERROR `#[diag(nonsense = ...)]` is not a valid attribute //~^^ ERROR diagnostic slug not specified struct InvalidNestedStructAttr3 {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123", slug = "foo")] //~^ ERROR `#[diag(slug = ...)]` is not a valid attribute struct InvalidNestedStructAttr4 {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct WrongPlaceField { #[suggestion = "bar"] @@ -98,36 +98,36 @@ struct WrongPlaceField { sp: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[diag(typeck::ambiguous_lifetime_bound, code = "E0456")] //~^ ERROR specified multiple times //~^^ ERROR specified multiple times struct DiagSpecifiedTwice {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0456", code = "E0457")] //~^ ERROR specified multiple times struct CodeSpecifiedTwice {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, typeck::ambiguous_lifetime_bound, code = "E0456")] //~^ ERROR `#[diag(typeck::ambiguous_lifetime_bound)]` is not a valid attribute struct SlugSpecifiedTwice {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] struct KindNotProvided {} //~ ERROR diagnostic slug not specified -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(code = "E0456")] //~^ ERROR diagnostic slug not specified struct SlugNotProvided {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound)] struct CodeNotProvided {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct MessageWrongType { #[primary_span] @@ -135,7 +135,7 @@ struct MessageWrongType { foo: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct InvalidPathFieldAttr { #[nonsense] @@ -144,7 +144,7 @@ struct InvalidPathFieldAttr { foo: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithField { name: String, @@ -152,7 +152,7 @@ struct ErrorWithField { span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithMessageAppliedToField { #[label(typeck::label)] @@ -160,7 +160,7 @@ struct ErrorWithMessageAppliedToField { name: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithNonexistentField { #[suggestion(typeck::suggestion, code = "{name}")] @@ -168,7 +168,7 @@ struct ErrorWithNonexistentField { suggestion: (Span, Applicability), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] //~^ ERROR invalid format string: expected `'}'` #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorMissingClosingBrace { @@ -178,7 +178,7 @@ struct ErrorMissingClosingBrace { val: usize, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] //~^ ERROR invalid format string: unmatched `}` #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorMissingOpeningBrace { @@ -188,14 +188,14 @@ struct ErrorMissingOpeningBrace { val: usize, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct LabelOnSpan { #[label(typeck::label)] sp: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct LabelOnNonSpan { #[label(typeck::label)] @@ -203,7 +203,7 @@ struct LabelOnNonSpan { id: u32, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct Suggest { #[suggestion(typeck::suggestion, code = "This is the suggested code")] @@ -213,14 +213,14 @@ struct Suggest { suggestion: (Span, Applicability), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithoutCode { #[suggestion(typeck::suggestion)] suggestion: (Span, Applicability), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithBadKey { #[suggestion(nonsense = "bar")] @@ -228,7 +228,7 @@ struct SuggestWithBadKey { suggestion: (Span, Applicability), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithShorthandMsg { #[suggestion(msg = "bar")] @@ -236,21 +236,21 @@ struct SuggestWithShorthandMsg { suggestion: (Span, Applicability), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithoutMsg { #[suggestion(code = "bar")] suggestion: (Span, Applicability), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithTypesSwapped { #[suggestion(typeck::suggestion, code = "This is suggested code")] suggestion: (Applicability, Span), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithWrongTypeApplicabilityOnly { #[suggestion(typeck::suggestion, code = "This is suggested code")] @@ -258,14 +258,14 @@ struct SuggestWithWrongTypeApplicabilityOnly { suggestion: Applicability, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithSpanOnly { #[suggestion(typeck::suggestion, code = "This is suggested code")] suggestion: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithDuplicateSpanAndApplicability { #[suggestion(typeck::suggestion, code = "This is suggested code")] @@ -273,7 +273,7 @@ struct SuggestWithDuplicateSpanAndApplicability { suggestion: (Span, Span, Applicability), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct SuggestWithDuplicateApplicabilityAndSpan { #[suggestion(typeck::suggestion, code = "This is suggested code")] @@ -281,7 +281,7 @@ struct SuggestWithDuplicateApplicabilityAndSpan { suggestion: (Applicability, Applicability, Span), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct WrongKindOfAnnotation { #[label = "bar"] @@ -289,7 +289,7 @@ struct WrongKindOfAnnotation { z: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct OptionsInErrors { #[label(typeck::label)] @@ -298,7 +298,7 @@ struct OptionsInErrors { opt_sugg: Option<(Span, Applicability)>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0456")] struct MoveOutOfBorrowError<'tcx> { name: Ident, @@ -312,7 +312,7 @@ struct MoveOutOfBorrowError<'tcx> { opt_sugg: Option<(Span, Applicability)>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithLifetime<'a> { #[label(typeck::label)] @@ -320,7 +320,7 @@ struct ErrorWithLifetime<'a> { name: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithDefaultLabelAttr<'a> { #[label] @@ -328,7 +328,7 @@ struct ErrorWithDefaultLabelAttr<'a> { name: &'a str, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] //~^ ERROR the trait bound `Hello: IntoDiagnosticArg` is not satisfied #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ArgFieldWithoutSkip { @@ -337,7 +337,7 @@ struct ArgFieldWithoutSkip { other: Hello, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ArgFieldWithSkip { #[primary_span] @@ -348,91 +348,91 @@ struct ArgFieldWithSkip { other: Hello, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithSpannedNote { #[note] span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithSpannedNoteCustom { #[note(typeck::note)] span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[note] struct ErrorWithNote { val: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[note(typeck::note)] struct ErrorWithNoteCustom { val: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithSpannedHelp { #[help] span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithSpannedHelpCustom { #[help(typeck::help)] span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[help] struct ErrorWithHelp { val: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[help(typeck::help)] struct ErrorWithHelpCustom { val: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[help] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithHelpWrongOrder { val: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[help(typeck::help)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithHelpCustomWrongOrder { val: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[note] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithNoteWrongOrder { val: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[note(typeck::note)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithNoteCustomWrongOrder { val: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ApplicabilityInBoth { #[suggestion(typeck::suggestion, code = "...", applicability = "maybe-incorrect")] @@ -440,7 +440,7 @@ struct ApplicabilityInBoth { suggestion: (Span, Applicability), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct InvalidApplicability { #[suggestion(typeck::suggestion, code = "...", applicability = "batman")] @@ -448,14 +448,14 @@ struct InvalidApplicability { suggestion: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ValidApplicability { #[suggestion(typeck::suggestion, code = "...", applicability = "maybe-incorrect")] suggestion: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct NoApplicability { #[suggestion(typeck::suggestion, code = "...")] @@ -466,14 +466,14 @@ struct NoApplicability { #[note(parser::add_paren)] struct Note; -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound)] struct Subdiagnostic { #[subdiagnostic] note: Note, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct VecField { #[primary_span] @@ -481,7 +481,7 @@ struct VecField { spans: Vec, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct UnitField { #[primary_span] @@ -492,7 +492,7 @@ struct UnitField { bar: (), } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct OptUnitField { #[primary_span] @@ -503,7 +503,7 @@ struct OptUnitField { bar: Option<()>, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct LabelWithTrailingPath { #[label(typeck::label, foo)] @@ -511,7 +511,7 @@ struct LabelWithTrailingPath { span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct LabelWithTrailingNameValue { #[label(typeck::label, foo = "...")] @@ -519,7 +519,7 @@ struct LabelWithTrailingNameValue { span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct LabelWithTrailingList { #[label(typeck::label, foo("..."))] @@ -540,35 +540,35 @@ struct PrimarySpanOnLint { span: Span, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] struct ErrorWithMultiSpan { #[primary_span] span: MultiSpan, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] #[warning] struct ErrorWithWarn { val: String, } -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[error(typeck::ambiguous_lifetime_bound, code = "E0123")] //~^ ERROR `#[error(...)]` is not a valid attribute //~| ERROR diagnostic slug not specified //~| ERROR cannot find attribute `error` in this scope struct ErrorAttribute {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[warn_(typeck::ambiguous_lifetime_bound, code = "E0123")] //~^ ERROR `#[warn_(...)]` is not a valid attribute //~| ERROR diagnostic slug not specified //~| ERROR cannot find attribute `warn_` in this scope struct WarnAttribute {} -#[derive(DiagnosticHandler)] +#[derive(Diagnostic)] #[lint(typeck::ambiguous_lifetime_bound, code = "E0123")] //~^ ERROR `#[lint(...)]` is not a valid attribute //~| ERROR diagnostic slug not specified diff --git a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr index d9198d4ef80..b07b35f2723 100644 --- a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr +++ b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr @@ -1,9 +1,9 @@ -error: `#[derive(DiagnosticHandler)]` can only be used on structs +error: `#[derive(Diagnostic)]` can only be used on structs --> $DIR/diagnostic-derive.rs:39:1 | LL | / #[diag(typeck::ambiguous_lifetime_bound, code = "E0123")] LL | | -LL | | enum DiagnosticHandlerOnEnum { +LL | | enum DiagnosticOnEnum { LL | | Foo, LL | | Bar, LL | | } @@ -214,22 +214,22 @@ LL | #[suggestion(typeck::suggestion, code = "{name}")] error: invalid format string: expected `'}'` but string was terminated --> $DIR/diagnostic-derive.rs:171:16 | -LL | #[derive(DiagnosticHandler)] +LL | #[derive(Diagnostic)] | - ^ expected `'}'` in format string | | | because of this opening brace | = note: if you intended to print `{`, you can escape it using `{{` - = note: this error originates in the derive macro `DiagnosticHandler` (in Nightly builds, run with -Z macro-backtrace for more info) + = note: this error originates in the derive macro `Diagnostic` (in Nightly builds, run with -Z macro-backtrace for more info) error: invalid format string: unmatched `}` found --> $DIR/diagnostic-derive.rs:181:15 | -LL | #[derive(DiagnosticHandler)] +LL | #[derive(Diagnostic)] | ^ unmatched `}` in format string | = note: if you intended to print `}`, you can escape it using `}}` - = note: this error originates in the derive macro `DiagnosticHandler` (in Nightly builds, run with -Z macro-backtrace for more info) + = note: this error originates in the derive macro `Diagnostic` (in Nightly builds, run with -Z macro-backtrace for more info) error: the `#[label(...)]` attribute can only be applied to fields of type `Span` or `MultiSpan` --> $DIR/diagnostic-derive.rs:201:5 @@ -448,7 +448,7 @@ LL | #[diag(nonsense, code = "E0123")] error[E0277]: the trait bound `Hello: IntoDiagnosticArg` is not satisfied --> $DIR/diagnostic-derive.rs:331:10 | -LL | #[derive(DiagnosticHandler)] +LL | #[derive(Diagnostic)] | ^^^^^^^^^^^^^^^^^ the trait `IntoDiagnosticArg` is not implemented for `Hello` | = help: normalized in stderr @@ -457,7 +457,7 @@ note: required by a bound in `DiagnosticBuilder::<'a, G>::set_arg` | LL | arg: impl IntoDiagnosticArg, | ^^^^^^^^^^^^^^^^^ required by this bound in `DiagnosticBuilder::<'a, G>::set_arg` - = note: this error originates in the derive macro `DiagnosticHandler` (in Nightly builds, run with -Z macro-backtrace for more info) + = note: this error originates in the derive macro `Diagnostic` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to 55 previous errors -- cgit 1.4.1-3-g733a5 From 5f91719f75a1012f4b59391fd89a20bb989b2801 Mon Sep 17 00:00:00 2001 From: Jhonny Bill Mena Date: Sun, 18 Sep 2022 11:47:31 -0400 Subject: UPDATE - rename SessionSubdiagnostic macro to Subdiagnostic Also renames: - sym::AddSubdiagnostic to sym:: Subdiagnostic - rustc_diagnostic_item = "AddSubdiagnostic" to rustc_diagnostic_item = "Subdiagnostic" --- compiler/rustc_ast_lowering/src/errors.rs | 4 +- compiler/rustc_ast_passes/src/errors.rs | 2 +- compiler/rustc_attr/src/session_diagnostics.rs | 4 +- compiler/rustc_borrowck/src/session_diagnostics.rs | 12 +- compiler/rustc_error_messages/src/lib.rs | 4 +- compiler/rustc_errors/src/diagnostic.rs | 9 +- compiler/rustc_expand/src/mbe/macro_rules.rs | 2 +- compiler/rustc_lint/src/errors.rs | 4 +- compiler/rustc_lint/src/internal.rs | 2 +- compiler/rustc_macros/src/diagnostics/mod.rs | 10 +- .../rustc_macros/src/diagnostics/subdiagnostic.rs | 18 +-- compiler/rustc_macros/src/lib.rs | 2 +- compiler/rustc_middle/src/error.rs | 2 +- compiler/rustc_parse/src/parser/diagnostics.rs | 14 +-- compiler/rustc_passes/src/errors.rs | 4 +- compiler/rustc_privacy/src/errors.rs | 4 +- compiler/rustc_query_system/src/error.rs | 7 +- compiler/rustc_session/src/errors.rs | 4 +- compiler/rustc_span/src/symbol.rs | 2 +- compiler/rustc_ty_utils/src/errors.rs | 4 +- compiler/rustc_typeck/src/errors.rs | 6 +- src/test/ui-fulldeps/internal-lints/diagnostics.rs | 4 +- .../session-diagnostic/diagnostic-derive.rs | 4 +- .../session-diagnostic/subdiagnostic-derive.rs | 130 ++++++++++----------- 24 files changed, 130 insertions(+), 128 deletions(-) (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs index 6dbb2582a37..052979d6d45 100644 --- a/compiler/rustc_ast_lowering/src/errors.rs +++ b/compiler/rustc_ast_lowering/src/errors.rs @@ -1,5 +1,5 @@ use rustc_errors::{fluent, AddToDiagnostic, Applicability, Diagnostic, DiagnosticArgFromDisplay}; -use rustc_macros::{Diagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_span::{symbol::Ident, Span, Symbol}; #[derive(Diagnostic, Clone, Copy)] @@ -221,7 +221,7 @@ pub struct InvalidAsmTemplateModifierRegClass { pub sub: InvalidAsmTemplateModifierRegClassSub, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum InvalidAsmTemplateModifierRegClassSub { #[note(ast_lowering::support_modifiers)] SupportModifier { class_name: Symbol, modifiers: String }, diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs index 20e2209acbe..035f0ce1cbc 100644 --- a/compiler/rustc_ast_passes/src/errors.rs +++ b/compiler/rustc_ast_passes/src/errors.rs @@ -71,7 +71,7 @@ pub struct InvalidVisibility { pub note: Option, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum InvalidVisibilityNote { #[note(ast_passes::individual_impl_items)] IndividualImplItems, diff --git a/compiler/rustc_attr/src/session_diagnostics.rs b/compiler/rustc_attr/src/session_diagnostics.rs index 5e8f9b79850..940a48ed915 100644 --- a/compiler/rustc_attr/src/session_diagnostics.rs +++ b/compiler/rustc_attr/src/session_diagnostics.rs @@ -98,7 +98,7 @@ pub(crate) struct InvalidIssueString { // The error kinds of `IntErrorKind` are duplicated here in order to allow the messages to be // translatable. -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum InvalidIssueStringCause { #[label(attr::must_not_be_zero)] MustNotBeZero { @@ -274,7 +274,7 @@ pub(crate) struct IncorrectReprFormatGeneric<'a> { pub cause: Option>, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum IncorrectReprFormatGenericCause<'a> { #[suggestion(attr::suggestion, code = "{name}({int})", applicability = "machine-applicable")] Int { diff --git a/compiler/rustc_borrowck/src/session_diagnostics.rs b/compiler/rustc_borrowck/src/session_diagnostics.rs index aa8f26eece5..9f19453a1a6 100644 --- a/compiler/rustc_borrowck/src/session_diagnostics.rs +++ b/compiler/rustc_borrowck/src/session_diagnostics.rs @@ -1,5 +1,5 @@ use rustc_errors::{IntoDiagnosticArg, MultiSpan}; -use rustc_macros::{Diagnostic, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic}; use rustc_middle::ty::Ty; use rustc_span::Span; @@ -23,7 +23,7 @@ pub(crate) struct HigherRankedLifetimeError { pub span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum HigherRankedErrorCause { #[note(borrowck::could_not_prove)] CouldNotProve { predicate: String }, @@ -72,7 +72,7 @@ pub(crate) struct FnMutError { pub ty_err: FnMutReturnTypeErr, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum VarHereDenote { #[label(borrowck::var_here_captured)] Captured { @@ -91,7 +91,7 @@ pub(crate) enum VarHereDenote { }, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum FnMutReturnTypeErr { #[label(borrowck::returned_closure_escaped)] ReturnClosure { @@ -117,7 +117,7 @@ pub(crate) struct LifetimeOutliveErr { pub span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum LifetimeReturnCategoryErr<'a> { #[label(borrowck::returned_lifetime_wrong)] WrongReturn { @@ -149,7 +149,7 @@ impl IntoDiagnosticArg for RegionName { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum RequireStaticErr { #[note(borrowck::used_impl_require_static)] UsedImpl { diff --git a/compiler/rustc_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs index b6e0f3faa73..ff33ae7e8f2 100644 --- a/compiler/rustc_error_messages/src/lib.rs +++ b/compiler/rustc_error_messages/src/lib.rs @@ -268,14 +268,14 @@ type FluentId = Cow<'static, str>; /// Translatable messages for subdiagnostics are typically attributes attached to a larger Fluent /// message so messages of this type must be combined with a `DiagnosticMessage` (using /// `DiagnosticMessage::with_subdiagnostic_message`) before rendering. However, subdiagnostics from -/// the `SessionSubdiagnostic` derive refer to Fluent identifiers directly. +/// the `Subdiagnostic` derive refer to Fluent identifiers directly. #[rustc_diagnostic_item = "SubdiagnosticMessage"] pub enum SubdiagnosticMessage { /// Non-translatable diagnostic message. // FIXME(davidtwco): can a `Cow<'static, str>` be used here? Str(String), /// Identifier of a Fluent message. Instances of this variant are generated by the - /// `SessionSubdiagnostic` derive. + /// `Subdiagnostic` derive. FluentIdentifier(FluentId), /// Attribute of a Fluent message. Needs to be combined with a Fluent identifier to produce an /// actual translated message. Instances of this variant are generated by the `fluent_messages` diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs index d3a263ac56d..c66889189ad 100644 --- a/compiler/rustc_errors/src/diagnostic.rs +++ b/compiler/rustc_errors/src/diagnostic.rs @@ -176,8 +176,9 @@ impl IntoDiagnosticArg for hir::ConstContext { } /// Trait implemented by error types. This should not be implemented manually. Instead, use -/// `#[derive(SessionSubdiagnostic)]` -- see [rustc_macros::SessionSubdiagnostic]. -#[rustc_diagnostic_item = "AddSubdiagnostic"] +/// `#[derive(Subdiagnostic)]` -- see [rustc_macros::Subdiagnostic]. +#[cfg_attr(bootstrap, rustc_diagnostic_item = "AddSubdiagnostic")] +#[cfg_attr(not(bootstrap), rustc_diagnostic_item = "Subdiagnostic")] pub trait AddToDiagnostic { /// Add a subdiagnostic to an existing diagnostic. fn add_to_diagnostic(self, diag: &mut Diagnostic); @@ -891,8 +892,8 @@ impl Diagnostic { self } - /// Add a subdiagnostic from a type that implements `SessionSubdiagnostic` - see - /// [rustc_macros::SessionSubdiagnostic]. + /// Add a subdiagnostic from a type that implements `Subdiagnostic` - see + /// [rustc_macros::Subdiagnostic]. pub fn subdiagnostic(&mut self, subdiagnostic: impl AddToDiagnostic) -> &mut Self { subdiagnostic.add_to_diagnostic(self); self diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs index 7764ffd246e..6d2c7aac6af 100644 --- a/compiler/rustc_expand/src/mbe/macro_rules.rs +++ b/compiler/rustc_expand/src/mbe/macro_rules.rs @@ -593,7 +593,7 @@ pub fn compile_declarative_macro( (mk_syn_ext(expander), rule_spans) } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum ExplainDocComment { #[label(expand::explain_doc_comment_inner)] Inner { diff --git a/compiler/rustc_lint/src/errors.rs b/compiler/rustc_lint/src/errors.rs index 0c66ce475c4..3a89d90c88a 100644 --- a/compiler/rustc_lint/src/errors.rs +++ b/compiler/rustc_lint/src/errors.rs @@ -1,5 +1,5 @@ use rustc_errors::{fluent, AddToDiagnostic, IntoDiagnostic, ErrorGuaranteed, Handler}; -use rustc_macros::{Diagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_session::lint::Level; use rustc_span::{Span, Symbol}; @@ -51,7 +51,7 @@ pub struct MalformedAttribute { pub sub: MalformedAttributeSub, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum MalformedAttributeSub { #[label(lint::bad_attribute_argument)] BadAttributeArgument(#[primary_span] Span), diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs index 36d8ade22ae..942475d31fe 100644 --- a/compiler/rustc_lint/src/internal.rs +++ b/compiler/rustc_lint/src/internal.rs @@ -404,7 +404,7 @@ impl LateLintPass<'_> for Diagnostics { let Impl { of_trait: Some(of_trait), .. } = impl_ && let Some(def_id) = of_trait.trait_def_id() && let Some(name) = cx.tcx.get_diagnostic_name(def_id) && - matches!(name, sym::Diagnostic | sym::AddSubdiagnostic | sym::DecorateLint) + matches!(name, sym::Diagnostic | sym::Subdiagnostic | sym::DecorateLint) { found_impl = true; break; diff --git a/compiler/rustc_macros/src/diagnostics/mod.rs b/compiler/rustc_macros/src/diagnostics/mod.rs index 1d5b32c2556..8eaa8b87c0f 100644 --- a/compiler/rustc_macros/src/diagnostics/mod.rs +++ b/compiler/rustc_macros/src/diagnostics/mod.rs @@ -9,7 +9,7 @@ use diagnostic::{LintDiagnosticDerive, SessionDiagnosticDerive}; pub(crate) use fluent::fluent_messages; use proc_macro2::TokenStream; use quote::format_ident; -use subdiagnostic::SessionSubdiagnosticDerive; +use subdiagnostic::SubdiagnosticDerive; use synstructure::Structure; /// Implements `#[derive(Diagnostic)]`, which allows for errors to be specified as a struct, @@ -108,12 +108,12 @@ pub fn lint_diagnostic_derive(s: Structure<'_>) -> TokenStream { LintDiagnosticDerive::new(format_ident!("diag"), s).into_tokens() } -/// Implements `#[derive(SessionSubdiagnostic)]`, which allows for labels, notes, helps and +/// Implements `#[derive(Subdiagnostic)]`, which allows for labels, notes, helps and /// suggestions to be specified as a structs or enums, independent from the actual diagnostics /// emitting code or diagnostic derives. /// /// ```ignore (rust) -/// #[derive(SessionSubdiagnostic)] +/// #[derive(Subdiagnostic)] /// pub enum ExpectedIdentifierLabel<'tcx> { /// #[label(parser::expected_identifier)] /// WithoutFound { @@ -128,7 +128,7 @@ pub fn lint_diagnostic_derive(s: Structure<'_>) -> TokenStream { /// } /// } /// -/// #[derive(SessionSubdiagnostic)] +/// #[derive(Subdiagnostic)] /// #[suggestion_verbose(parser::raw_identifier)] /// pub struct RawIdentifierSuggestion<'tcx> { /// #[primary_span] @@ -155,5 +155,5 @@ pub fn lint_diagnostic_derive(s: Structure<'_>) -> TokenStream { /// diag.subdiagnostic(RawIdentifierSuggestion { span, applicability, ident }); /// ``` pub fn session_subdiagnostic_derive(s: Structure<'_>) -> TokenStream { - SessionSubdiagnosticDerive::new(s).into_tokens() + SubdiagnosticDerive::new(s).into_tokens() } diff --git a/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs b/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs index f1bb7feb062..bdeca3420bc 100644 --- a/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs +++ b/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs @@ -98,19 +98,19 @@ impl quote::IdentFragment for SubdiagnosticKind { } /// The central struct for constructing the `add_to_diagnostic` method from an annotated struct. -pub(crate) struct SessionSubdiagnosticDerive<'a> { +pub(crate) struct SubdiagnosticDerive<'a> { structure: Structure<'a>, diag: syn::Ident, } -impl<'a> SessionSubdiagnosticDerive<'a> { +impl<'a> SubdiagnosticDerive<'a> { pub(crate) fn new(structure: Structure<'a>) -> Self { let diag = format_ident!("diag"); Self { structure, diag } } pub(crate) fn into_tokens(self) -> TokenStream { - let SessionSubdiagnosticDerive { mut structure, diag } = self; + let SubdiagnosticDerive { mut structure, diag } = self; let implementation = { let ast = structure.ast(); let span = ast.span().unwrap(); @@ -119,7 +119,7 @@ impl<'a> SessionSubdiagnosticDerive<'a> { syn::Data::Union(..) => { span_err( span, - "`#[derive(SessionSubdiagnostic)]` can only be used on structs and enums", + "`#[derive(Subdiagnostic)]` can only be used on structs and enums", ); } } @@ -146,7 +146,7 @@ impl<'a> SessionSubdiagnosticDerive<'a> { } } - let mut builder = SessionSubdiagnosticDeriveBuilder { + let mut builder = SubdiagnosticDeriveBuilder { diag: &diag, variant, span, @@ -178,10 +178,10 @@ impl<'a> SessionSubdiagnosticDerive<'a> { } /// Tracks persistent information required for building up the call to add to the diagnostic -/// for the final generated method. This is a separate struct to `SessionSubdiagnosticDerive` +/// for the final generated method. This is a separate struct to `SubdiagnosticDerive` /// only to be able to destructure and split `self.builder` and the `self.structure` up to avoid a /// double mut borrow later on. -struct SessionSubdiagnosticDeriveBuilder<'a> { +struct SubdiagnosticDeriveBuilder<'a> { /// The identifier to use for the generated `DiagnosticBuilder` instance. diag: &'a syn::Ident, @@ -205,7 +205,7 @@ struct SessionSubdiagnosticDeriveBuilder<'a> { has_suggestion_parts: bool, } -impl<'a> HasFieldMap for SessionSubdiagnosticDeriveBuilder<'a> { +impl<'a> HasFieldMap for SubdiagnosticDeriveBuilder<'a> { fn get_field_binding(&self, field: &String) -> Option<&TokenStream> { self.fields.get(field) } @@ -241,7 +241,7 @@ impl<'a> FromIterator<&'a SubdiagnosticKind> for KindsStatistics { } } -impl<'a> SessionSubdiagnosticDeriveBuilder<'a> { +impl<'a> SubdiagnosticDeriveBuilder<'a> { fn identify_kind(&mut self) -> Result, DiagnosticDeriveError> { let mut kind_slugs = vec![]; diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs index 9dd7ccad8bb..8fd23ee5ced 100644 --- a/compiler/rustc_macros/src/lib.rs +++ b/compiler/rustc_macros/src/lib.rs @@ -161,7 +161,7 @@ decl_derive!( suggestion_verbose)] => diagnostics::lint_diagnostic_derive ); decl_derive!( - [SessionSubdiagnostic, attributes( + [Subdiagnostic, attributes( // struct/variant attributes label, help, diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs index 6d15feb888a..a4ceb494569 100644 --- a/compiler/rustc_middle/src/error.rs +++ b/compiler/rustc_middle/src/error.rs @@ -25,7 +25,7 @@ pub struct OpaqueHiddenTypeMismatch<'tcx> { pub sub: TypeMismatchReason, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum TypeMismatchReason { #[label(middle::conflict_types)] ConflictType { diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs index 9989ebb7cdf..78bc29fc375 100644 --- a/compiler/rustc_parse/src/parser/diagnostics.rs +++ b/compiler/rustc_parse/src/parser/diagnostics.rs @@ -20,7 +20,7 @@ use rustc_errors::{ fluent, Applicability, DiagnosticBuilder, DiagnosticMessage, Handler, MultiSpan, PResult, }; use rustc_errors::{pluralize, struct_span_err, Diagnostic, ErrorGuaranteed}; -use rustc_macros::{Diagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_span::source_map::Spanned; use rustc_span::symbol::{kw, sym, Ident}; use rustc_span::{Span, SpanSnippetError, DUMMY_SP}; @@ -261,7 +261,7 @@ struct BadTypePlus { pub sub: BadTypePlusSub, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum BadTypePlusSub { #[suggestion( parser::add_paren, @@ -342,7 +342,7 @@ pub struct InvalidVariableDeclaration { pub sub: InvalidVariableDeclarationSub, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum InvalidVariableDeclarationSub { #[suggestion( parser::switch_mut_let_order, @@ -372,7 +372,7 @@ pub(crate) struct InvalidComparisonOperator { pub sub: InvalidComparisonOperatorSub, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum InvalidComparisonOperatorSub { #[suggestion_short( parser::use_instead, @@ -400,7 +400,7 @@ pub(crate) struct InvalidLogicalOperator { pub sub: InvalidLogicalOperatorSub, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum InvalidLogicalOperatorSub { #[suggestion_short( parser::use_amp_amp_for_conjunction, @@ -605,7 +605,7 @@ pub(crate) struct IfExpressionMissingThenBlock { pub sub: IfExpressionMissingThenBlockSub, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum IfExpressionMissingThenBlockSub { #[help(parser::condition_possibly_unfinished)] UnfinishedCondition(#[primary_span] Span), @@ -668,7 +668,7 @@ pub(crate) struct MissingInInForLoop { pub sub: MissingInInForLoopSub, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub(crate) enum MissingInInForLoopSub { // Has been misleading, at least in the past (closed Issue #48492), thus maybe-incorrect #[suggestion_short(parser::use_in_not_of, applicability = "maybe-incorrect", code = "in")] diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs index bff2978bd13..52aea9bba43 100644 --- a/compiler/rustc_passes/src/errors.rs +++ b/compiler/rustc_passes/src/errors.rs @@ -1,5 +1,5 @@ use rustc_errors::{Applicability, MultiSpan}; -use rustc_macros::{Diagnostic, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic}; use rustc_span::{Span, Symbol}; #[derive(LintDiagnostic)] @@ -583,7 +583,7 @@ pub struct MacroExport; #[diag(passes::plugin_registrar)] pub struct PluginRegistrar; -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum UnusedNote { #[note(passes::unused_empty_lints_note)] EmptyList { name: Symbol }, diff --git a/compiler/rustc_privacy/src/errors.rs b/compiler/rustc_privacy/src/errors.rs index 71552119482..f3a617c2f0f 100644 --- a/compiler/rustc_privacy/src/errors.rs +++ b/compiler/rustc_privacy/src/errors.rs @@ -1,5 +1,5 @@ use rustc_errors::DiagnosticArgFromDisplay; -use rustc_macros::{Diagnostic, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic}; use rustc_span::{Span, Symbol}; #[derive(Diagnostic)] @@ -14,7 +14,7 @@ pub struct FieldIsPrivate { pub label: FieldIsPrivateLabel, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum FieldIsPrivateLabel { #[label(privacy::field_is_private_is_update_syntax_label)] IsUpdateSyntax { diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs index 4c770152f12..ceec75fce28 100644 --- a/compiler/rustc_query_system/src/error.rs +++ b/compiler/rustc_query_system/src/error.rs @@ -1,6 +1,7 @@ use rustc_errors::AddToDiagnostic; use rustc_session::Limit; use rustc_span::{Span, Symbol}; +use rustc_macros::{Diagnostic, Subdiagnostic}; pub struct CycleStack { pub span: Span, @@ -20,7 +21,7 @@ pub enum HandleCycleError { DelayBug, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum StackCount { #[note(query_system::cycle_stack_single)] Single, @@ -28,7 +29,7 @@ pub enum StackCount { Multiple, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum Alias { #[note(query_system::cycle_recursive_ty_alias)] #[help(query_system::cycle_recursive_ty_alias_help1)] @@ -38,7 +39,7 @@ pub enum Alias { Trait, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[note(query_system::cycle_usage)] pub struct CycleUsage { #[primary_span] diff --git a/compiler/rustc_session/src/errors.rs b/compiler/rustc_session/src/errors.rs index 7ffe757463f..997a45272bc 100644 --- a/compiler/rustc_session/src/errors.rs +++ b/compiler/rustc_session/src/errors.rs @@ -34,13 +34,13 @@ pub struct FeatureGateError<'a> { pub explain: &'a str, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[note(session::feature_diagnostic_for_issue)] pub struct FeatureDiagnosticForIssue { pub n: NonZeroU32, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[help(session::feature_diagnostic_help)] pub struct FeatureDiagnosticHelp { pub feature: Symbol, diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index ea69334616b..1baad6a9fd7 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -125,7 +125,6 @@ symbols! { Symbols { AcqRel, Acquire, - AddSubdiagnostic, Alignment, Any, Arc, @@ -283,6 +282,7 @@ symbols! { String, StructuralEq, StructuralPartialEq, + Subdiagnostic, SubdiagnosticMessage, Sync, T, diff --git a/compiler/rustc_ty_utils/src/errors.rs b/compiler/rustc_ty_utils/src/errors.rs index 85165187310..753c474a34b 100644 --- a/compiler/rustc_ty_utils/src/errors.rs +++ b/compiler/rustc_ty_utils/src/errors.rs @@ -1,6 +1,6 @@ //! Errors emitted by ty_utils -use rustc_macros::{Diagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_middle::ty::Ty; use rustc_span::Span; @@ -22,7 +22,7 @@ pub struct GenericConstantTooComplex { pub sub: GenericConstantTooComplexSub, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum GenericConstantTooComplexSub { #[label(ty_utils::borrow_not_supported)] BorrowNotSupported(#[primary_span] Span), diff --git a/compiler/rustc_typeck/src/errors.rs b/compiler/rustc_typeck/src/errors.rs index 6f00591d54e..44df47e2fa0 100644 --- a/compiler/rustc_typeck/src/errors.rs +++ b/compiler/rustc_typeck/src/errors.rs @@ -1,7 +1,7 @@ //! Errors emitted by typeck. use rustc_errors::IntoDiagnostic; use rustc_errors::{error_code, Applicability, DiagnosticBuilder, ErrorGuaranteed, Handler}; -use rustc_macros::{Diagnostic, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic}; use rustc_middle::ty::Ty; use rustc_span::{symbol::Ident, Span, Symbol}; @@ -194,7 +194,7 @@ pub struct AddressOfTemporaryTaken { pub span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum AddReturnTypeSuggestion { #[suggestion( typeck::add_return_type_add, @@ -217,7 +217,7 @@ pub enum AddReturnTypeSuggestion { }, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum ExpectedReturnTypeLabel<'tcx> { #[label(typeck::expected_default_return_type)] Unit { diff --git a/src/test/ui-fulldeps/internal-lints/diagnostics.rs b/src/test/ui-fulldeps/internal-lints/diagnostics.rs index 93766de9a91..4c2c28dc336 100644 --- a/src/test/ui-fulldeps/internal-lints/diagnostics.rs +++ b/src/test/ui-fulldeps/internal-lints/diagnostics.rs @@ -15,7 +15,7 @@ use rustc_errors::{ AddToDiagnostic, IntoDiagnostic, Diagnostic, DiagnosticBuilder, ErrorGuaranteed, Handler, fluent }; -use rustc_macros::{Diagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_span::Span; #[derive(Diagnostic)] @@ -25,7 +25,7 @@ struct DeriveSessionDiagnostic { span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[note(parser::add_paren)] struct Note { #[primary_span] diff --git a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs index fd8128c31f8..80ea9082881 100644 --- a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs +++ b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.rs @@ -17,7 +17,7 @@ use rustc_span::symbol::Ident; use rustc_span::Span; extern crate rustc_macros; -use rustc_macros::{Diagnostic, LintDiagnostic, SessionSubdiagnostic}; +use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic}; extern crate rustc_middle; use rustc_middle::ty::Ty; @@ -462,7 +462,7 @@ struct NoApplicability { suggestion: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[note(parser::add_paren)] struct Note; diff --git a/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.rs b/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.rs index 812ca0c72bd..9fbe7b1f4c8 100644 --- a/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.rs +++ b/src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.rs @@ -1,8 +1,8 @@ // check-fail -// Tests error conditions for specifying subdiagnostics using #[derive(SessionSubdiagnostic)] +// Tests error conditions for specifying subdiagnostics using #[derive(Subdiagnostic)] // The proc_macro2 crate handles spans differently when on beta/stable release rather than nightly, -// changing the output of this test. Since SessionSubdiagnostic is strictly internal to the compiler +// changing the output of this test. Since Subdiagnostic is strictly internal to the compiler // the test is just ignored on stable and beta: // ignore-beta // ignore-stable @@ -17,9 +17,9 @@ extern crate rustc_macros; use rustc_errors::Applicability; use rustc_span::Span; -use rustc_macros::SessionSubdiagnostic; +use rustc_macros::Subdiagnostic; -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren)] struct A { #[primary_span] @@ -27,7 +27,7 @@ struct A { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum B { #[label(parser::add_paren)] A { @@ -43,14 +43,14 @@ enum B { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren)] //~^ ERROR label without `#[primary_span]` field struct C { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label] //~^ ERROR `#[label]` is not a valid attribute struct D { @@ -59,7 +59,7 @@ struct D { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[foo] //~^ ERROR `#[foo]` is not a valid attribute //~^^ ERROR cannot find attribute `foo` in this scope @@ -69,7 +69,7 @@ struct E { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label = "..."] //~^ ERROR `#[label = ...]` is not a valid attribute struct F { @@ -78,7 +78,7 @@ struct F { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(bug = "...")] //~^ ERROR `#[label(bug = ...)]` is not a valid attribute struct G { @@ -87,7 +87,7 @@ struct G { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label("...")] //~^ ERROR `#[label("...")]` is not a valid attribute struct H { @@ -96,7 +96,7 @@ struct H { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(slug = 4)] //~^ ERROR `#[label(slug = ...)]` is not a valid attribute struct J { @@ -105,7 +105,7 @@ struct J { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(slug("..."))] //~^ ERROR `#[label(slug(...))]` is not a valid attribute struct K { @@ -114,7 +114,7 @@ struct K { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(slug)] //~^ ERROR cannot find value `slug` in module `rustc_errors::fluent` //~^^ NOTE not found in `rustc_errors::fluent` @@ -124,7 +124,7 @@ struct L { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label()] //~^ ERROR diagnostic slug must be first argument of a `#[label(...)]` attribute struct M { @@ -133,7 +133,7 @@ struct M { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren, code = "...")] //~^ ERROR `code` is not a valid nested attribute of a `label` attribute struct N { @@ -142,7 +142,7 @@ struct N { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren, applicability = "machine-applicable")] //~^ ERROR `applicability` is not a valid nested attribute of a `label` attribute struct O { @@ -151,7 +151,7 @@ struct O { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[foo] //~^ ERROR cannot find attribute `foo` in this scope //~^^ ERROR unsupported type attribute for subdiagnostic enum @@ -164,7 +164,7 @@ enum P { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum Q { #[bar] //~^ ERROR `#[bar]` is not a valid attribute @@ -176,7 +176,7 @@ enum Q { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum R { #[bar = "..."] //~^ ERROR `#[bar = ...]` is not a valid attribute @@ -188,7 +188,7 @@ enum R { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum S { #[bar = 4] //~^ ERROR `#[bar = ...]` is not a valid attribute @@ -200,7 +200,7 @@ enum S { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum T { #[bar("...")] //~^ ERROR `#[bar(...)]` is not a valid attribute @@ -212,7 +212,7 @@ enum T { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum U { #[label(code = "...")] //~^ ERROR diagnostic slug must be first argument of a `#[label(...)]` attribute @@ -223,7 +223,7 @@ enum U { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum V { #[label(parser::add_paren)] A { @@ -239,7 +239,7 @@ enum V { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren)] //~^ ERROR label without `#[primary_span]` field struct W { @@ -248,7 +248,7 @@ struct W { span: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren)] struct X { #[primary_span] @@ -258,7 +258,7 @@ struct X { applicability: Applicability, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren)] struct Y { #[primary_span] @@ -269,7 +269,7 @@ struct Y { bar: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren)] struct Z { #[primary_span] @@ -280,7 +280,7 @@ struct Z { bar: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren)] struct AA { #[primary_span] @@ -291,7 +291,7 @@ struct AA { bar: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren)] struct AB { #[primary_span] @@ -300,14 +300,14 @@ struct AB { z: Z } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] union AC { //~^ ERROR unexpected unsupported untagged union span: u32, b: u64 } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren)] #[label(parser::add_paren)] struct AD { @@ -315,7 +315,7 @@ struct AD { span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren, parser::add_paren)] //~^ ERROR `#[label(parser::add_paren)]` is not a valid attribute struct AE { @@ -323,7 +323,7 @@ struct AE { span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(parser::add_paren)] struct AF { #[primary_span] @@ -334,14 +334,14 @@ struct AF { span_b: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] struct AG { //~^ ERROR subdiagnostic kind not specified #[primary_span] span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code = "...")] struct AH { #[primary_span] @@ -351,7 +351,7 @@ struct AH { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum AI { #[suggestion(parser::add_paren, code = "...")] A { @@ -371,7 +371,7 @@ enum AI { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code = "...", code = "...")] //~^ ERROR specified multiple times //~^^ NOTE previously specified here @@ -382,7 +382,7 @@ struct AJ { applicability: Applicability, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code = "...")] struct AK { #[primary_span] @@ -395,7 +395,7 @@ struct AK { applicability_b: Applicability, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code = "...")] struct AL { #[primary_span] @@ -405,14 +405,14 @@ struct AL { applicability: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code = "...")] struct AM { #[primary_span] span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren)] //~^ ERROR suggestion without `code = "..."` struct AN { @@ -422,7 +422,7 @@ struct AN { applicability: Applicability, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code ="...", applicability = "foo")] //~^ ERROR invalid applicability struct AO { @@ -430,31 +430,31 @@ struct AO { span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[help(parser::add_paren)] struct AP { var: String } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[note(parser::add_paren)] struct AQ; -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code = "...")] //~^ ERROR suggestion without `#[primary_span]` field struct AR { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code ="...", applicability = "machine-applicable")] struct AS { #[primary_span] span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label] //~^ ERROR unsupported type attribute for subdiagnostic enum enum AT { @@ -466,7 +466,7 @@ enum AT { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")] struct AU { #[primary_span] @@ -474,7 +474,7 @@ struct AU { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")] //~^ ERROR `var` doesn't refer to a field on this type struct AV { @@ -482,7 +482,7 @@ struct AV { span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum AW { #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")] A { @@ -492,7 +492,7 @@ enum AW { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] enum AX { #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")] //~^ ERROR `var` doesn't refer to a field on this type @@ -502,18 +502,18 @@ enum AX { } } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[warning(parser::add_paren)] struct AY {} -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[warning(parser::add_paren)] struct AZ { #[primary_span] span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[suggestion(parser::add_paren, code = "...")] //~^ ERROR suggestion without `#[primary_span]` field struct BA { @@ -528,7 +528,7 @@ struct BA { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[multipart_suggestion(parser::add_paren, code = "...", applicability = "machine-applicable")] //~^ ERROR multipart suggestion without any `#[suggestion_part(...)]` fields //~| ERROR `code` is not a valid nested attribute of a `multipart_suggestion` attribute @@ -536,7 +536,7 @@ struct BBa { var: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] struct BBb { #[suggestion_part] @@ -544,7 +544,7 @@ struct BBb { span1: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] struct BBc { #[suggestion_part()] @@ -552,7 +552,7 @@ struct BBc { span1: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[multipart_suggestion(parser::add_paren)] //~^ ERROR multipart suggestion without any `#[suggestion_part(...)]` fields struct BC { @@ -561,7 +561,7 @@ struct BC { span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[multipart_suggestion(parser::add_paren)] struct BD { #[suggestion_part] @@ -581,7 +581,7 @@ struct BD { s2: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] struct BE { #[suggestion_part(code = "...", code = ",,,")] @@ -590,7 +590,7 @@ struct BE { span: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] struct BF { #[suggestion_part(code = "(")] @@ -599,7 +599,7 @@ struct BF { second: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[multipart_suggestion(parser::add_paren)] struct BG { #[applicability] @@ -610,7 +610,7 @@ struct BG { second: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] //~^ NOTE previously specified here struct BH { @@ -623,7 +623,7 @@ struct BH { second: Span, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[multipart_suggestion(parser::add_paren, applicability = "machine-applicable")] struct BI { #[suggestion_part(code = "")] -- cgit 1.4.1-3-g733a5 From e52e2344dc574922ce4f8ddfd508f8bfdec3f404 Mon Sep 17 00:00:00 2001 From: Jhonny Bill Mena Date: Thu, 15 Sep 2022 00:01:44 -0400 Subject: FIX - adopt new Diagnostic naming in newly migrated modules FIX - ambiguous Diagnostic link in docs UPDATE - rename diagnostic_items to IntoDiagnostic and AddToDiagnostic [Gardening] FIX - formatting via `x fmt` FIX - rebase conflicts. NOTE: Confirm wheather or not we want to handle TargetDataLayoutErrorsWrapper this way DELETE - unneeded allow attributes in Handler method FIX - broken test FIX - Rebase conflict UPDATE - rename residual _SessionDiagnostic and fix LintDiag link --- compiler/rustc_ast_lowering/src/errors.rs | 2 +- compiler/rustc_attr/src/session_diagnostics.rs | 3 +- compiler/rustc_errors/src/diagnostic.rs | 2 +- compiler/rustc_errors/src/diagnostic_builder.rs | 2 +- compiler/rustc_errors/src/lib.rs | 44 +---------------- compiler/rustc_expand/src/base.rs | 2 +- compiler/rustc_infer/src/errors/mod.rs | 36 +++++++------- .../rustc_infer/src/errors/note_and_explain.rs | 4 +- .../nice_region_error/different_lifetimes.rs | 2 +- compiler/rustc_lint/src/errors.rs | 2 +- compiler/rustc_lint/src/internal.rs | 2 +- .../rustc_macros/src/diagnostics/diagnostic.rs | 6 +-- compiler/rustc_macros/src/diagnostics/mod.rs | 6 +-- compiler/rustc_metadata/src/errors.rs | 2 +- compiler/rustc_middle/src/ty/context.rs | 3 +- compiler/rustc_monomorphize/src/errors.rs | 2 +- compiler/rustc_parse/src/parser/diagnostics.rs | 4 +- compiler/rustc_passes/src/errors.rs | 2 +- compiler/rustc_query_system/src/error.rs | 2 +- compiler/rustc_query_system/src/query/job.rs | 2 +- compiler/rustc_session/src/config.rs | 3 +- compiler/rustc_session/src/errors.rs | 56 +++++++++++----------- compiler/rustc_session/src/parse.rs | 4 +- compiler/rustc_session/src/session.rs | 4 +- compiler/rustc_span/src/symbol.rs | 4 +- compiler/rustc_trait_selection/src/errors.rs | 2 +- src/test/ui-fulldeps/internal-lints/diagnostics.rs | 10 ++-- .../session-diagnostic/diagnostic-derive.stderr | 2 +- 28 files changed, 88 insertions(+), 127 deletions(-) (limited to 'compiler/rustc_query_system/src/error.rs') diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs index 052979d6d45..1ad5fa21d85 100644 --- a/compiler/rustc_ast_lowering/src/errors.rs +++ b/compiler/rustc_ast_lowering/src/errors.rs @@ -335,7 +335,7 @@ pub struct InclusiveRangeWithNoEnd { pub span: Span, } -#[derive(SessionDiagnostic, Clone, Copy)] +#[derive(Diagnostic, Clone, Copy)] #[diag(ast_lowering::trait_fn_async, code = "E0706")] #[note] #[note(ast_lowering::note2)] diff --git a/compiler/rustc_attr/src/session_diagnostics.rs b/compiler/rustc_attr/src/session_diagnostics.rs index 940a48ed915..d3e9a16a9a8 100644 --- a/compiler/rustc_attr/src/session_diagnostics.rs +++ b/compiler/rustc_attr/src/session_diagnostics.rs @@ -2,8 +2,7 @@ use std::num::IntErrorKind; use rustc_ast as ast; use rustc_errors::{ - error_code, fluent, Applicability, DiagnosticBuilder, IntoDiagnostic, ErrorGuaranteed, - Handler, + error_code, fluent, Applicability, DiagnosticBuilder, ErrorGuaranteed, Handler, IntoDiagnostic, }; use rustc_macros::Diagnostic; use rustc_span::{Span, Symbol}; diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs index c66889189ad..a52e95e92d5 100644 --- a/compiler/rustc_errors/src/diagnostic.rs +++ b/compiler/rustc_errors/src/diagnostic.rs @@ -178,7 +178,7 @@ impl IntoDiagnosticArg for hir::ConstContext { /// Trait implemented by error types. This should not be implemented manually. Instead, use /// `#[derive(Subdiagnostic)]` -- see [rustc_macros::Subdiagnostic]. #[cfg_attr(bootstrap, rustc_diagnostic_item = "AddSubdiagnostic")] -#[cfg_attr(not(bootstrap), rustc_diagnostic_item = "Subdiagnostic")] +#[cfg_attr(not(bootstrap), rustc_diagnostic_item = "AddToDiagnostic")] pub trait AddToDiagnostic { /// Add a subdiagnostic to an existing diagnostic. fn add_to_diagnostic(self, diag: &mut Diagnostic); diff --git a/compiler/rustc_errors/src/diagnostic_builder.rs b/compiler/rustc_errors/src/diagnostic_builder.rs index f9b46053486..b4ba65ca96d 100644 --- a/compiler/rustc_errors/src/diagnostic_builder.rs +++ b/compiler/rustc_errors/src/diagnostic_builder.rs @@ -16,7 +16,7 @@ use std::thread::panicking; /// Trait implemented by error types. This should not be implemented manually. Instead, use /// `#[derive(Diagnostic)]` -- see [rustc_macros::Diagnostic]. #[cfg_attr(bootstrap, rustc_diagnostic_item = "SessionDiagnostic")] -#[cfg_attr(not(bootstrap), rustc_diagnostic_item = "Diagnostic")] +#[cfg_attr(not(bootstrap), rustc_diagnostic_item = "IntoDiagnostic")] pub trait IntoDiagnostic<'a, T: EmissionGuarantee = ErrorGuaranteed> { /// Write out as a diagnostic out of `Handler`. #[must_use] diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs index 19cae2c9077..68971cebc35 100644 --- a/compiler/rustc_errors/src/lib.rs +++ b/compiler/rustc_errors/src/lib.rs @@ -437,11 +437,11 @@ struct HandlerInner { /// have been converted. check_unstable_expect_diagnostics: bool, - /// Expected [`Diagnostic`]s store a [`LintExpectationId`] as part of + /// Expected [`Diagnostic`][diagnostic::Diagnostic]s store a [`LintExpectationId`] as part of /// the lint level. [`LintExpectationId`]s created early during the compilation /// (before `HirId`s have been defined) are not stable and can therefore not be /// stored on disk. This buffer stores these diagnostics until the ID has been - /// replaced by a stable [`LintExpectationId`]. The [`Diagnostic`]s are the + /// replaced by a stable [`LintExpectationId`]. The [`Diagnostic`][diagnostic::Diagnostic]s are the /// submitted for storage and added to the list of fulfilled expectations. unstable_expect_diagnostics: Vec, @@ -647,8 +647,6 @@ impl Handler { /// Construct a builder with the `msg` at the level appropriate for the specific `EmissionGuarantee`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_diagnostic( &self, msg: impl Into, @@ -662,8 +660,6 @@ impl Handler { /// * `can_emit_warnings` is `true` /// * `is_force_warn` was set in `DiagnosticId::Lint` #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_warn( &self, span: impl Into, @@ -680,8 +676,6 @@ impl Handler { /// Attempting to `.emit()` the builder will only emit if either: /// * `can_emit_warnings` is `true` /// * `is_force_warn` was set in `DiagnosticId::Lint` - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_warn_with_expectation( &self, span: impl Into, @@ -695,8 +689,6 @@ impl Handler { /// Construct a builder at the `Allow` level at the given `span` and with the `msg`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_allow( &self, span: impl Into, @@ -710,8 +702,6 @@ impl Handler { /// Construct a builder at the `Warning` level at the given `span` and with the `msg`. /// Also include a code. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_warn_with_code( &self, span: impl Into, @@ -729,8 +719,6 @@ impl Handler { /// * `can_emit_warnings` is `true` /// * `is_force_warn` was set in `DiagnosticId::Lint` #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_warn(&self, msg: impl Into) -> DiagnosticBuilder<'_, ()> { DiagnosticBuilder::new(self, Level::Warning(None), msg) } @@ -741,8 +729,6 @@ impl Handler { /// Attempting to `.emit()` the builder will only emit if either: /// * `can_emit_warnings` is `true` /// * `is_force_warn` was set in `DiagnosticId::Lint` - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_warn_with_expectation( &self, msg: impl Into, @@ -753,16 +739,12 @@ impl Handler { /// Construct a builder at the `Allow` level with the `msg`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_allow(&self, msg: impl Into) -> DiagnosticBuilder<'_, ()> { DiagnosticBuilder::new(self, Level::Allow, msg) } /// Construct a builder at the `Expect` level with the `msg`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_expect( &self, msg: impl Into, @@ -773,8 +755,6 @@ impl Handler { /// Construct a builder at the `Error` level at the given `span` and with the `msg`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_err( &self, span: impl Into, @@ -787,8 +767,6 @@ impl Handler { /// Construct a builder at the `Error` level at the given `span`, with the `msg`, and `code`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_err_with_code( &self, span: impl Into, @@ -803,8 +781,6 @@ impl Handler { /// Construct a builder at the `Error` level with the `msg`. // FIXME: This method should be removed (every error should have an associated error code). #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_err( &self, msg: impl Into, @@ -814,16 +790,12 @@ impl Handler { /// This should only be used by `rustc_middle::lint::struct_lint_level`. Do not use it for hard errors. #[doc(hidden)] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_err_lint(&self, msg: impl Into) -> DiagnosticBuilder<'_, ()> { DiagnosticBuilder::new(self, Level::Error { lint: true }, msg) } /// Construct a builder at the `Error` level with the `msg` and the `code`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_err_with_code( &self, msg: impl Into, @@ -836,8 +808,6 @@ impl Handler { /// Construct a builder at the `Warn` level with the `msg` and the `code`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_warn_with_code( &self, msg: impl Into, @@ -850,8 +820,6 @@ impl Handler { /// Construct a builder at the `Fatal` level at the given `span` and with the `msg`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_fatal( &self, span: impl Into, @@ -864,8 +832,6 @@ impl Handler { /// Construct a builder at the `Fatal` level at the given `span`, with the `msg`, and `code`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_span_fatal_with_code( &self, span: impl Into, @@ -879,24 +845,18 @@ impl Handler { /// Construct a builder at the `Error` level with the `msg`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_fatal(&self, msg: impl Into) -> DiagnosticBuilder<'_, !> { DiagnosticBuilder::new_fatal(self, msg) } /// Construct a builder at the `Help` level with the `msg`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_help(&self, msg: impl Into) -> DiagnosticBuilder<'_, ()> { DiagnosticBuilder::new(self, Level::Help, msg) } /// Construct a builder at the `Note` level with the `msg`. #[rustc_lint_diagnostics] - #[allow(rustc::diagnostic_outside_of_impl)] - #[allow(rustc::untranslatable_diagnostic)] pub fn struct_note_without_error( &self, msg: impl Into, diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs index ca429b6adc1..cd8a525e062 100644 --- a/compiler/rustc_expand/src/base.rs +++ b/compiler/rustc_expand/src/base.rs @@ -11,7 +11,7 @@ use rustc_attr::{self as attr, Deprecation, Stability}; use rustc_data_structures::fx::{FxHashSet, FxIndexMap}; use rustc_data_structures::sync::{self, Lrc}; use rustc_errors::{ - Applicability, DiagnosticBuilder, IntoDiagnostic, ErrorGuaranteed, MultiSpan, PResult, + Applicability, DiagnosticBuilder, ErrorGuaranteed, IntoDiagnostic, MultiSpan, PResult, }; use rustc_lint_defs::builtin::PROC_MACRO_BACK_COMPAT; use rustc_lint_defs::{BufferedEarlyLint, BuiltinLintDiagnostics}; diff --git a/compiler/rustc_infer/src/errors/mod.rs b/compiler/rustc_infer/src/errors/mod.rs index d232a186462..85b877652c6 100644 --- a/compiler/rustc_infer/src/errors/mod.rs +++ b/compiler/rustc_infer/src/errors/mod.rs @@ -1,10 +1,10 @@ use hir::GenericParamKind; use rustc_errors::{ - fluent, AddSubdiagnostic, Applicability, DiagnosticMessage, DiagnosticStyledString, MultiSpan, + fluent, AddToDiagnostic, Applicability, DiagnosticMessage, DiagnosticStyledString, MultiSpan, }; use rustc_hir as hir; use rustc_hir::{FnRetTy, Ty}; -use rustc_macros::SessionDiagnostic; +use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_middle::ty::{Region, TyCtxt}; use rustc_span::symbol::kw; use rustc_span::{symbol::Ident, BytePos, Span}; @@ -16,7 +16,7 @@ use crate::infer::error_reporting::{ pub mod note_and_explain; -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(infer::opaque_hidden_type)] pub struct OpaqueHiddenTypeDiag { #[primary_span] @@ -28,7 +28,7 @@ pub struct OpaqueHiddenTypeDiag { pub hidden_type: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(infer::type_annotations_needed, code = "E0282")] pub struct AnnotationRequired<'a> { #[primary_span] @@ -46,7 +46,7 @@ pub struct AnnotationRequired<'a> { } // Copy of `AnnotationRequired` for E0283 -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(infer::type_annotations_needed, code = "E0283")] pub struct AmbigousImpl<'a> { #[primary_span] @@ -64,7 +64,7 @@ pub struct AmbigousImpl<'a> { } // Copy of `AnnotationRequired` for E0284 -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(infer::type_annotations_needed, code = "E0284")] pub struct AmbigousReturn<'a> { #[primary_span] @@ -81,7 +81,7 @@ pub struct AmbigousReturn<'a> { pub multi_suggestions: Vec>, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(infer::need_type_info_in_generator, code = "E0698")] pub struct NeedTypeInfoInGenerator<'a> { #[primary_span] @@ -92,7 +92,7 @@ pub struct NeedTypeInfoInGenerator<'a> { } // Used when a better one isn't available -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] #[label(infer::label_bad)] pub struct InferenceBadError<'a> { #[primary_span] @@ -106,7 +106,7 @@ pub struct InferenceBadError<'a> { pub name: String, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum SourceKindSubdiag<'a> { #[suggestion_verbose( infer::source_kind_subdiag_let, @@ -147,7 +147,7 @@ pub enum SourceKindSubdiag<'a> { }, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum SourceKindMultiSuggestion<'a> { #[multipart_suggestion_verbose( infer::source_kind_fully_qualified, @@ -228,7 +228,7 @@ pub enum RegionOriginNote<'a> { }, } -impl AddSubdiagnostic for RegionOriginNote<'_> { +impl AddToDiagnostic for RegionOriginNote<'_> { fn add_to_diagnostic(self, diag: &mut rustc_errors::Diagnostic) { let mut label_or_note = |span, msg: DiagnosticMessage| { let sub_count = diag.children.iter().filter(|d| d.span.is_dummy()).count(); @@ -289,7 +289,7 @@ pub enum LifetimeMismatchLabels { }, } -impl AddSubdiagnostic for LifetimeMismatchLabels { +impl AddToDiagnostic for LifetimeMismatchLabels { fn add_to_diagnostic(self, diag: &mut rustc_errors::Diagnostic) { match self { LifetimeMismatchLabels::InRet { param_span, ret_span, span, label_var1 } => { @@ -339,7 +339,7 @@ pub struct AddLifetimeParamsSuggestion<'a> { pub add_note: bool, } -impl AddSubdiagnostic for AddLifetimeParamsSuggestion<'_> { +impl AddToDiagnostic for AddLifetimeParamsSuggestion<'_> { fn add_to_diagnostic(self, diag: &mut rustc_errors::Diagnostic) { let mut mk_suggestion = || { let ( @@ -422,7 +422,7 @@ impl AddSubdiagnostic for AddLifetimeParamsSuggestion<'_> { } } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(infer::lifetime_mismatch, code = "E0623")] pub struct LifetimeMismatch<'a> { #[primary_span] @@ -438,7 +438,7 @@ pub struct IntroducesStaticBecauseUnmetLifetimeReq { pub binding_span: Span, } -impl AddSubdiagnostic for IntroducesStaticBecauseUnmetLifetimeReq { +impl AddToDiagnostic for IntroducesStaticBecauseUnmetLifetimeReq { fn add_to_diagnostic(mut self, diag: &mut rustc_errors::Diagnostic) { self.unmet_requirements .push_span_label(self.binding_span, fluent::infer::msl_introduces_static); @@ -450,7 +450,7 @@ pub struct ImplNote { pub impl_span: Option, } -impl AddSubdiagnostic for ImplNote { +impl AddToDiagnostic for ImplNote { fn add_to_diagnostic(self, diag: &mut rustc_errors::Diagnostic) { match self.impl_span { Some(span) => diag.span_note(span, fluent::infer::msl_impl_note), @@ -465,7 +465,7 @@ pub enum TraitSubdiag { } // FIXME(#100717) used in `Vec` so requires eager translation/list support -impl AddSubdiagnostic for TraitSubdiag { +impl AddToDiagnostic for TraitSubdiag { fn add_to_diagnostic(self, diag: &mut rustc_errors::Diagnostic) { match self { TraitSubdiag::Note { span } => { @@ -483,7 +483,7 @@ impl AddSubdiagnostic for TraitSubdiag { } } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(infer::mismatched_static_lifetime)] pub struct MismatchedStaticLifetime<'a> { #[primary_span] diff --git a/compiler/rustc_infer/src/errors/note_and_explain.rs b/compiler/rustc_infer/src/errors/note_and_explain.rs index 7e051835b4b..7f54918f736 100644 --- a/compiler/rustc_infer/src/errors/note_and_explain.rs +++ b/compiler/rustc_infer/src/errors/note_and_explain.rs @@ -1,5 +1,5 @@ use crate::infer::error_reporting::nice_region_error::find_anon_type; -use rustc_errors::{self, fluent, AddSubdiagnostic, IntoDiagnosticArg}; +use rustc_errors::{self, fluent, AddToDiagnostic, IntoDiagnosticArg}; use rustc_middle::ty::{self, TyCtxt}; use rustc_span::{symbol::kw, Span}; @@ -158,7 +158,7 @@ impl RegionExplanation<'_> { } } -impl AddSubdiagnostic for RegionExplanation<'_> { +impl AddToDiagnostic for RegionExplanation<'_> { fn add_to_diagnostic(self, diag: &mut rustc_errors::Diagnostic) { if let Some(span) = self.desc.span { diag.span_note(span, fluent::infer::region_explanation); diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/different_lifetimes.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/different_lifetimes.rs index 3a4320a9a8f..da0271a345e 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/different_lifetimes.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/different_lifetimes.rs @@ -11,7 +11,7 @@ use crate::infer::lexical_region_resolve::RegionResolutionError; use crate::infer::SubregionOrigin; use crate::infer::TyCtxt; -use rustc_errors::AddSubdiagnostic; +use rustc_errors::AddToDiagnostic; use rustc_errors::{Diagnostic, ErrorGuaranteed}; use rustc_hir::Ty; use rustc_middle::ty::Region; diff --git a/compiler/rustc_lint/src/errors.rs b/compiler/rustc_lint/src/errors.rs index 3a89d90c88a..880f3fbd00e 100644 --- a/compiler/rustc_lint/src/errors.rs +++ b/compiler/rustc_lint/src/errors.rs @@ -1,4 +1,4 @@ -use rustc_errors::{fluent, AddToDiagnostic, IntoDiagnostic, ErrorGuaranteed, Handler}; +use rustc_errors::{fluent, AddToDiagnostic, ErrorGuaranteed, Handler, IntoDiagnostic}; use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_session::lint::Level; use rustc_span::{Span, Symbol}; diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs index 942475d31fe..d8a03024d13 100644 --- a/compiler/rustc_lint/src/internal.rs +++ b/compiler/rustc_lint/src/internal.rs @@ -404,7 +404,7 @@ impl LateLintPass<'_> for Diagnostics { let Impl { of_trait: Some(of_trait), .. } = impl_ && let Some(def_id) = of_trait.trait_def_id() && let Some(name) = cx.tcx.get_diagnostic_name(def_id) && - matches!(name, sym::Diagnostic | sym::Subdiagnostic | sym::DecorateLint) + matches!(name, sym::IntoDiagnostic | sym::AddToDiagnostic | sym::DecorateLint) { found_impl = true; break; diff --git a/compiler/rustc_macros/src/diagnostics/diagnostic.rs b/compiler/rustc_macros/src/diagnostics/diagnostic.rs index c1aae04fcee..3b8d9594eb9 100644 --- a/compiler/rustc_macros/src/diagnostics/diagnostic.rs +++ b/compiler/rustc_macros/src/diagnostics/diagnostic.rs @@ -9,13 +9,13 @@ use syn::spanned::Spanned; use synstructure::Structure; /// The central struct for constructing the `into_diagnostic` method from an annotated struct. -pub(crate) struct SessionDiagnosticDerive<'a> { +pub(crate) struct DiagnosticDerive<'a> { structure: Structure<'a>, handler: syn::Ident, builder: DiagnosticDeriveBuilder, } -impl<'a> SessionDiagnosticDerive<'a> { +impl<'a> DiagnosticDerive<'a> { pub(crate) fn new(diag: syn::Ident, handler: syn::Ident, structure: Structure<'a>) -> Self { Self { builder: DiagnosticDeriveBuilder { @@ -31,7 +31,7 @@ impl<'a> SessionDiagnosticDerive<'a> { } pub(crate) fn into_tokens(self) -> TokenStream { - let SessionDiagnosticDerive { mut structure, handler, mut builder } = self; + let DiagnosticDerive { mut structure, handler, mut builder } = self; let ast = structure.ast(); let implementation = { diff --git a/compiler/rustc_macros/src/diagnostics/mod.rs b/compiler/rustc_macros/src/diagnostics/mod.rs index 8eaa8b87c0f..4166816b5e3 100644 --- a/compiler/rustc_macros/src/diagnostics/mod.rs +++ b/compiler/rustc_macros/src/diagnostics/mod.rs @@ -5,7 +5,7 @@ mod fluent; mod subdiagnostic; mod utils; -use diagnostic::{LintDiagnosticDerive, SessionDiagnosticDerive}; +use diagnostic::{DiagnosticDerive, LintDiagnosticDerive}; pub(crate) use fluent::fluent_messages; use proc_macro2::TokenStream; use quote::format_ident; @@ -59,7 +59,7 @@ use synstructure::Structure; /// See rustc dev guide for more examples on using the `#[derive(Diagnostic)]`: /// pub fn session_diagnostic_derive(s: Structure<'_>) -> TokenStream { - SessionDiagnosticDerive::new(format_ident!("diag"), format_ident!("handler"), s).into_tokens() + DiagnosticDerive::new(format_ident!("diag"), format_ident!("handler"), s).into_tokens() } /// Implements `#[derive(LintDiagnostic)]`, which allows for lints to be specified as a struct, @@ -103,7 +103,7 @@ pub fn session_diagnostic_derive(s: Structure<'_>) -> TokenStream { /// ``` /// /// See rustc dev guide for more examples on using the `#[derive(LintDiagnostic)]`: -/// +/// pub fn lint_diagnostic_derive(s: Structure<'_>) -> TokenStream { LintDiagnosticDerive::new(format_ident!("diag"), s).into_tokens() } diff --git a/compiler/rustc_metadata/src/errors.rs b/compiler/rustc_metadata/src/errors.rs index 8ff4eb5fdbc..1cd550644bf 100644 --- a/compiler/rustc_metadata/src/errors.rs +++ b/compiler/rustc_metadata/src/errors.rs @@ -3,7 +3,7 @@ use std::{ path::{Path, PathBuf}, }; -use rustc_errors::{error_code, IntoDiagnostic, ErrorGuaranteed}; +use rustc_errors::{error_code, ErrorGuaranteed, IntoDiagnostic}; use rustc_macros::Diagnostic; use rustc_session::config; use rustc_span::{sym, Span, Symbol}; diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 10c5933574f..2b5b4017a5a 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -53,6 +53,7 @@ use rustc_query_system::ich::StableHashingContext; use rustc_serialize::opaque::{FileEncodeResult, FileEncoder}; use rustc_session::config::{CrateType, OutputFilenames}; use rustc_session::cstore::CrateStoreDyn; +use rustc_session::errors::TargetDataLayoutErrorsWrapper; use rustc_session::lint::Lint; use rustc_session::Limit; use rustc_session::Session; @@ -1245,7 +1246,7 @@ impl<'tcx> TyCtxt<'tcx> { output_filenames: OutputFilenames, ) -> GlobalCtxt<'tcx> { let data_layout = TargetDataLayout::parse(&s.target).unwrap_or_else(|err| { - s.emit_fatal(err); + s.emit_fatal(TargetDataLayoutErrorsWrapper(err)); }); let interners = CtxtInterners::new(arena); let common_types = CommonTypes::new( diff --git a/compiler/rustc_monomorphize/src/errors.rs b/compiler/rustc_monomorphize/src/errors.rs index cdc2c74ac8f..cf6e18c013b 100644 --- a/compiler/rustc_monomorphize/src/errors.rs +++ b/compiler/rustc_monomorphize/src/errors.rs @@ -1,7 +1,7 @@ use std::path::PathBuf; -use rustc_errors::IntoDiagnostic; use rustc_errors::ErrorGuaranteed; +use rustc_errors::IntoDiagnostic; use rustc_macros::{Diagnostic, LintDiagnostic}; use rustc_span::Span; diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs index 78bc29fc375..dcea11eadcb 100644 --- a/compiler/rustc_parse/src/parser/diagnostics.rs +++ b/compiler/rustc_parse/src/parser/diagnostics.rs @@ -434,7 +434,7 @@ pub(crate) struct NotAsNegationOperator { pub sub: NotAsNegationOperatorSub, } -#[derive(SessionSubdiagnostic)] +#[derive(Subdiagnostic)] pub enum NotAsNegationOperatorSub { #[suggestion_short( parser::unexpected_token_after_not_default, @@ -737,7 +737,7 @@ pub(crate) struct RemoveLet { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(parser::use_eq_instead)] pub(crate) struct UseEqInstead { #[primary_span] diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs index 52aea9bba43..be67c9e3b82 100644 --- a/compiler/rustc_passes/src/errors.rs +++ b/compiler/rustc_passes/src/errors.rs @@ -650,7 +650,7 @@ pub struct RustcLintOptDenyFieldAccess { pub span: Span, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(passes::collapse_debuginfo)] pub struct CollapseDebuginfo { #[primary_span] diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs index ceec75fce28..8602a4cf5ae 100644 --- a/compiler/rustc_query_system/src/error.rs +++ b/compiler/rustc_query_system/src/error.rs @@ -1,7 +1,7 @@ use rustc_errors::AddToDiagnostic; +use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_session::Limit; use rustc_span::{Span, Symbol}; -use rustc_macros::{Diagnostic, Subdiagnostic}; pub struct CycleStack { pub span: Span, diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs index 6d26c8f47f3..64aba4703ca 100644 --- a/compiler/rustc_query_system/src/query/job.rs +++ b/compiler/rustc_query_system/src/query/job.rs @@ -4,7 +4,7 @@ use crate::query::{QueryContext, QueryStackFrame}; use rustc_data_structures::fx::FxHashMap; use rustc_errors::{ - Diagnostic, DiagnosticBuilder, IntoDiagnostic, ErrorGuaranteed, Handler, Level, + Diagnostic, DiagnosticBuilder, ErrorGuaranteed, Handler, IntoDiagnostic, Level, }; use rustc_hir::def::DefKind; use rustc_session::Session; diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs index 8bb3878fbbb..57c9a3f4822 100644 --- a/compiler/rustc_session/src/config.rs +++ b/compiler/rustc_session/src/config.rs @@ -3,6 +3,7 @@ pub use crate::options::*; +use crate::errors::TargetDataLayoutErrorsWrapper; use crate::search_paths::SearchPath; use crate::utils::{CanonicalizedPath, NativeLib, NativeLibKind}; use crate::{early_error, early_warn, Session}; @@ -898,7 +899,7 @@ fn default_configuration(sess: &Session) -> CrateConfig { let max_atomic_width = sess.target.max_atomic_width(); let atomic_cas = sess.target.atomic_cas; let layout = TargetDataLayout::parse(&sess.target).unwrap_or_else(|err| { - sess.emit_fatal(err); + sess.emit_fatal(TargetDataLayoutErrorsWrapper(err)); }); let mut ret = CrateConfig::default(); diff --git a/compiler/rustc_session/src/errors.rs b/compiler/rustc_session/src/errors.rs index 997a45272bc..e01dafe2102 100644 --- a/compiler/rustc_session/src/errors.rs +++ b/compiler/rustc_session/src/errors.rs @@ -1,9 +1,10 @@ use std::num::NonZeroU32; use crate::cgu_reuse_tracker::CguReuse; -use crate::{self as rustc_session, SessionDiagnostic}; -use rustc_errors::{fluent, DiagnosticBuilder, ErrorGuaranteed, Handler, MultiSpan}; -use rustc_macros::SessionDiagnostic; +use rustc_errors::{ + fluent, DiagnosticBuilder, ErrorGuaranteed, Handler, IntoDiagnostic, MultiSpan, +}; +use rustc_macros::Diagnostic; use rustc_span::{Span, Symbol}; use rustc_target::abi::TargetDataLayoutErrors; use rustc_target::spec::{SplitDebuginfo, StackProtector, TargetTriple}; @@ -46,10 +47,12 @@ pub struct FeatureDiagnosticHelp { pub feature: Symbol, } -impl IntoDiagnostic<'_, !> for TargetDataLayoutErrors<'_> { +pub struct TargetDataLayoutErrorsWrapper<'a>(pub TargetDataLayoutErrors<'a>); + +impl IntoDiagnostic<'_, !> for TargetDataLayoutErrorsWrapper<'_> { fn into_diagnostic(self, handler: &Handler) -> DiagnosticBuilder<'_, !> { let mut diag; - match self { + match self.0 { TargetDataLayoutErrors::InvalidAddressSpace { addr_space, err, cause } => { diag = handler.struct_fatal(fluent::session::target_invalid_address_space); diag.set_arg("addr_space", addr_space); @@ -97,87 +100,87 @@ impl IntoDiagnostic<'_, !> for TargetDataLayoutErrors<'_> { } } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::not_circumvent_feature)] pub struct NotCircumventFeature; -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::linker_plugin_lto_windows_not_supported)] pub struct LinkerPluginToWindowsNotSupported; -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::profile_use_file_does_not_exist)] pub struct ProfileUseFileDoesNotExist<'a> { pub path: &'a std::path::Path, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::profile_sample_use_file_does_not_exist)] pub struct ProfileSampleUseFileDoesNotExist<'a> { pub path: &'a std::path::Path, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::target_requires_unwind_tables)] pub struct TargetRequiresUnwindTables; -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::sanitizer_not_supported)] pub struct SanitizerNotSupported { pub us: String, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::sanitizers_not_supported)] pub struct SanitizersNotSupported { pub us: String, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::cannot_mix_and_match_sanitizers)] pub struct CannotMixAndMatchSanitizers { pub first: String, pub second: String, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::cannot_enable_crt_static_linux)] pub struct CannotEnableCrtStaticLinux; -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::sanitizer_cfi_enabled)] pub struct SanitizerCfiEnabled; -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::unstable_virtual_function_elimination)] pub struct UnstableVirtualFunctionElimination; -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::unsupported_dwarf_version)] pub struct UnsupportedDwarfVersion { pub dwarf_version: u32, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::target_stack_protector_not_supported)] pub struct StackProtectorNotSupportedForTarget<'a> { pub stack_protector: StackProtector, pub target_triple: &'a TargetTriple, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::split_debuginfo_unstable_platform)] pub struct SplitDebugInfoUnstablePlatform { pub debuginfo: SplitDebuginfo, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::file_is_not_writeable)] pub struct FileIsNotWriteable<'a> { pub file: &'a std::path::Path, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::crate_name_does_not_match)] pub struct CrateNameDoesNotMatch<'a> { #[primary_span] @@ -186,13 +189,13 @@ pub struct CrateNameDoesNotMatch<'a> { pub name: Symbol, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::crate_name_invalid)] pub struct CrateNameInvalid<'a> { pub s: &'a str, } -#[derive(SessionDiagnostic)] +#[derive(Diagnostic)] #[diag(session::crate_name_empty)] pub struct CrateNameEmpty { #[primary_span] @@ -205,11 +208,8 @@ pub struct InvalidCharacterInCrateName<'a> { pub crate_name: &'a str, } -impl crate::SessionDiagnostic<'_> for InvalidCharacterInCrateName<'_> { - fn into_diagnostic( - self, - sess: &Handler, - ) -> rustc_errors::DiagnosticBuilder<'_, ErrorGuaranteed> { +impl IntoDiagnostic<'_> for InvalidCharacterInCrateName<'_> { + fn into_diagnostic(self, sess: &Handler) -> DiagnosticBuilder<'_, ErrorGuaranteed> { let mut diag = sess.struct_err(fluent::session::invalid_character_in_create_name); if let Some(sp) = self.span { diag.set_span(sp); diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs index 3189dcb08ad..b9202af2a67 100644 --- a/compiler/rustc_session/src/parse.rs +++ b/compiler/rustc_session/src/parse.rs @@ -11,8 +11,8 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet}; use rustc_data_structures::sync::{Lock, Lrc}; use rustc_errors::{emitter::SilentEmitter, ColorConfig, Handler}; use rustc_errors::{ - fallback_fluent_bundle, Applicability, Diagnostic, DiagnosticBuilder, IntoDiagnostic, - DiagnosticId, DiagnosticMessage, EmissionGuarantee, ErrorGuaranteed, MultiSpan, StashKey, + fallback_fluent_bundle, Applicability, Diagnostic, DiagnosticBuilder, DiagnosticId, + DiagnosticMessage, EmissionGuarantee, ErrorGuaranteed, IntoDiagnostic, MultiSpan, StashKey, }; use rustc_feature::{find_feature_issue, GateIssue, UnstableFeatures}; use rustc_span::edition::Edition; diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs index e660b739928..0142e981766 100644 --- a/compiler/rustc_session/src/session.rs +++ b/compiler/rustc_session/src/session.rs @@ -27,8 +27,8 @@ use rustc_errors::emitter::{Emitter, EmitterWriter, HumanReadableErrorType}; use rustc_errors::json::JsonEmitter; use rustc_errors::registry::Registry; use rustc_errors::{ - error_code, fallback_fluent_bundle, DiagnosticBuilder, IntoDiagnostic, DiagnosticId, - DiagnosticMessage, ErrorGuaranteed, FluentBundle, LazyFallbackBundle, MultiSpan, + error_code, fallback_fluent_bundle, DiagnosticBuilder, DiagnosticId, DiagnosticMessage, + ErrorGuaranteed, FluentBundle, IntoDiagnostic, LazyFallbackBundle, MultiSpan, }; use rustc_macros::HashStable_Generic; pub use rustc_span::def_id::StableCrateId; diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 1baad6a9fd7..7785d29c15f 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -125,6 +125,7 @@ symbols! { Symbols { AcqRel, Acquire, + AddToDiagnostic, Alignment, Any, Arc, @@ -176,7 +177,6 @@ symbols! { DecorateLint, Default, Deref, - Diagnostic, DiagnosticMessage, DirBuilder, Display, @@ -210,6 +210,7 @@ symbols! { Implied, Input, Into, + IntoDiagnostic, IntoFuture, IntoIterator, IoRead, @@ -282,7 +283,6 @@ symbols! { String, StructuralEq, StructuralPartialEq, - Subdiagnostic, SubdiagnosticMessage, Sync, T, diff --git a/compiler/rustc_trait_selection/src/errors.rs b/compiler/rustc_trait_selection/src/errors.rs index b02ee593cbe..5e1b80eae39 100644 --- a/compiler/rustc_trait_selection/src/errors.rs +++ b/compiler/rustc_trait_selection/src/errors.rs @@ -1,4 +1,4 @@ -use rustc_errors::{fluent, IntoDiagnostic, ErrorGuaranteed, Handler}; +use rustc_errors::{fluent, ErrorGuaranteed, Handler, IntoDiagnostic}; use rustc_macros::Diagnostic; use rustc_middle::ty::{PolyTraitRef, Ty, Unevaluated}; use rustc_session::Limit; diff --git a/src/test/ui-fulldeps/internal-lints/diagnostics.rs b/src/test/ui-fulldeps/internal-lints/diagnostics.rs index 4c2c28dc336..18e39108eca 100644 --- a/src/test/ui-fulldeps/internal-lints/diagnostics.rs +++ b/src/test/ui-fulldeps/internal-lints/diagnostics.rs @@ -20,7 +20,7 @@ use rustc_span::Span; #[derive(Diagnostic)] #[diag(parser::expect_path)] -struct DeriveSessionDiagnostic { +struct DeriveDiagnostic { #[primary_span] span: Span, } @@ -32,18 +32,18 @@ struct Note { span: Span, } -pub struct UntranslatableInSessionDiagnostic; +pub struct UntranslatableInIntoDiagnostic; -impl<'a> IntoDiagnostic<'a, ErrorGuaranteed> for UntranslatableInSessionDiagnostic { +impl<'a> IntoDiagnostic<'a, ErrorGuaranteed> for UntranslatableInIntoDiagnostic { fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> { handler.struct_err("untranslatable diagnostic") //~^ ERROR diagnostics should be created using translatable messages } } -pub struct TranslatableInSessionDiagnostic; +pub struct TranslatableInIntoDiagnostic; -impl<'a> IntoDiagnostic<'a, ErrorGuaranteed> for TranslatableInSessionDiagnostic { +impl<'a> IntoDiagnostic<'a, ErrorGuaranteed> for TranslatableInIntoDiagnostic { fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> { handler.struct_err(fluent::parser::expect_path) } diff --git a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr index b07b35f2723..c3972beb512 100644 --- a/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr +++ b/src/test/ui-fulldeps/session-diagnostic/diagnostic-derive.stderr @@ -449,7 +449,7 @@ error[E0277]: the trait bound `Hello: IntoDiagnosticArg` is not satisfied --> $DIR/diagnostic-derive.rs:331:10 | LL | #[derive(Diagnostic)] - | ^^^^^^^^^^^^^^^^^ the trait `IntoDiagnosticArg` is not implemented for `Hello` + | ^^^^^^^^^^ the trait `IntoDiagnosticArg` is not implemented for `Hello` | = help: normalized in stderr note: required by a bound in `DiagnosticBuilder::<'a, G>::set_arg` -- cgit 1.4.1-3-g733a5