From 137f20c11265ea70e3ed3ed7798662b9abfbaad2 Mon Sep 17 00:00:00 2001 From: Nathan Stocks Date: Thu, 18 Aug 2022 15:51:47 -0600 Subject: rebased: convert rustc_monomorphize errors to SessionDiagnostic --- compiler/rustc_monomorphize/src/errors.rs | 81 +++++++++++++++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 compiler/rustc_monomorphize/src/errors.rs (limited to 'compiler/rustc_monomorphize/src/errors.rs') diff --git a/compiler/rustc_monomorphize/src/errors.rs b/compiler/rustc_monomorphize/src/errors.rs new file mode 100644 index 00000000000..62ebac97136 --- /dev/null +++ b/compiler/rustc_monomorphize/src/errors.rs @@ -0,0 +1,81 @@ +use std::path::PathBuf; + +use rustc_errors::ErrorGuaranteed; +use rustc_macros::{LintDiagnostic, SessionDiagnostic}; +use rustc_session::SessionDiagnostic; +// use rustc_session::SessionDiagnostic; +use rustc_span::Span; + +#[derive(SessionDiagnostic)] +#[diag(monomorphize::recursion_limit)] +pub struct RecursionLimit { + #[primary_span] + pub span: Span, + pub shrunk: String, + #[note] + pub def_span: Span, + pub def_path_str: String, + #[note(monomorphize::written_to_path)] + pub was_written: Option<()>, + pub path: PathBuf, +} + +#[derive(SessionDiagnostic)] +#[diag(monomorphize::type_length_limit)] +#[help(monomorphize::consider_type_length_limit)] +pub struct TypeLengthLimit { + #[primary_span] + pub span: Span, + pub shrunk: String, + #[note(monomorphize::written_to_path)] + pub was_written: Option<()>, + pub path: PathBuf, + pub type_length: usize, +} + +#[derive(SessionDiagnostic)] +#[diag(monomorphize::fatal_error)] +pub struct FatalError { + pub error_message: String, +} + +#[derive(SessionDiagnostic)] +#[diag(monomorphize::fatal_error)] +pub struct SpanFatalError { + #[primary_span] + pub span: Span, + pub error_message: String, +} + +pub struct UnusedGenericParams { + pub span: Span, + pub param_spans: Vec, + pub param_names: Vec, +} + +impl SessionDiagnostic<'_> for UnusedGenericParams { + fn into_diagnostic( + self, + sess: &'_ rustc_session::parse::ParseSess, + ) -> rustc_errors::DiagnosticBuilder<'_, ErrorGuaranteed> { + let mut diag = sess.struct_err(rustc_errors::fluent::monomorphize::unused_generic_params); + diag.set_span(self.span); + for (span, name) in self.param_spans.into_iter().zip(self.param_names) { + // FIXME: I can figure out how to do a label with a fluent string with a fixed message, + // or a label with a dynamic value in a hard-coded string, but I haven't figured out + // how to combine the two. 😢 + diag.span_label(span, format!("generic parameter `{}` is unused", name)); + } + diag + } +} + +#[derive(LintDiagnostic)] +#[diag(monomorphize::large_assignments)] +#[note] +pub struct LargeAssignmentsLint { + #[label] + pub span: Span, + pub size: u64, + pub limit: u64, +} -- cgit 1.4.1-3-g733a5 From 40f44736e805d0576918bb7679e2737a704590f1 Mon Sep 17 00:00:00 2001 From: Nathan Stocks Date: Tue, 23 Aug 2022 11:20:01 -0600 Subject: replace some usages of [Span]FatalError with error-specific types --- .../locales/en-US/monomorphize.ftl | 4 ++++ compiler/rustc_monomorphize/src/errors.rs | 20 ++++++++++++-------- compiler/rustc_monomorphize/src/partitioning/mod.rs | 13 +++---------- 3 files changed, 19 insertions(+), 18 deletions(-) (limited to 'compiler/rustc_monomorphize/src/errors.rs') diff --git a/compiler/rustc_error_messages/locales/en-US/monomorphize.ftl b/compiler/rustc_error_messages/locales/en-US/monomorphize.ftl index 4c67c6f5cb4..48ddb54b79e 100644 --- a/compiler/rustc_error_messages/locales/en-US/monomorphize.ftl +++ b/compiler/rustc_error_messages/locales/en-US/monomorphize.ftl @@ -11,6 +11,10 @@ monomorphize_consider_type_length_limit = monomorphize_fatal_error = {$error_message} +monomorphize_unknown_partition_strategy = unknown partitioning strategy + +monomorphize_symbol_already_defined = symbol `{$symbol}` is already defined + monomorphize_unused_generic_params = item has unused generic parameters monomorphize_large_assignments = diff --git a/compiler/rustc_monomorphize/src/errors.rs b/compiler/rustc_monomorphize/src/errors.rs index 62ebac97136..fa7655f2624 100644 --- a/compiler/rustc_monomorphize/src/errors.rs +++ b/compiler/rustc_monomorphize/src/errors.rs @@ -39,14 +39,6 @@ pub struct FatalError { pub error_message: String, } -#[derive(SessionDiagnostic)] -#[diag(monomorphize::fatal_error)] -pub struct SpanFatalError { - #[primary_span] - pub span: Span, - pub error_message: String, -} - pub struct UnusedGenericParams { pub span: Span, pub param_spans: Vec, @@ -79,3 +71,15 @@ pub struct LargeAssignmentsLint { pub size: u64, pub limit: u64, } + +#[derive(SessionDiagnostic)] +#[diag(monomorphize::unknown_partition_strategy)] +pub struct UnknownPartitionStrategy; + +#[derive(SessionDiagnostic)] +#[diag(monomorphize::symbol_already_defined)] +pub struct SymbolAlreadyDefined { + #[primary_span] + pub span: Option, + pub symbol: String, +} diff --git a/compiler/rustc_monomorphize/src/partitioning/mod.rs b/compiler/rustc_monomorphize/src/partitioning/mod.rs index d88b7e0a813..3d9197c7549 100644 --- a/compiler/rustc_monomorphize/src/partitioning/mod.rs +++ b/compiler/rustc_monomorphize/src/partitioning/mod.rs @@ -108,7 +108,7 @@ use rustc_span::symbol::Symbol; use crate::collector::InliningMap; use crate::collector::{self, MonoItemCollectionMode}; -use crate::errors::{FatalError, SpanFatalError}; +use crate::errors::{SymbolAlreadyDefined, UnknownPartitionStrategy}; pub struct PartitioningCx<'a, 'tcx> { tcx: TyCtxt<'tcx>, @@ -151,8 +151,7 @@ fn get_partitioner<'tcx>(tcx: TyCtxt<'tcx>) -> Box> { match strategy { "default" => Box::new(default::DefaultPartitioning), _ => { - let error_message = "unknown partitioning strategy".to_string(); - tcx.sess.emit_fatal(FatalError { error_message: error_message.clone() }); + tcx.sess.emit_fatal(UnknownPartitionStrategy); } } } @@ -335,13 +334,7 @@ where (span1, span2) => span1.or(span2), }; - let error_message = format!("symbol `{}` is already defined", sym1); - - if let Some(span) = span { - tcx.sess.emit_fatal(SpanFatalError { span, error_message: error_message.clone() }); - } else { - tcx.sess.emit_fatal(FatalError { error_message: error_message.clone() }); - } + tcx.sess.emit_fatal(SymbolAlreadyDefined { span, symbol: sym1.to_string() }); } } } -- cgit 1.4.1-3-g733a5 From 33cbbc2789304714f8c9da1370c5f2adb74addda Mon Sep 17 00:00:00 2001 From: Nathan Stocks Date: Tue, 23 Aug 2022 13:01:51 -0600 Subject: remove stray comment --- compiler/rustc_monomorphize/src/errors.rs | 1 - 1 file changed, 1 deletion(-) (limited to 'compiler/rustc_monomorphize/src/errors.rs') diff --git a/compiler/rustc_monomorphize/src/errors.rs b/compiler/rustc_monomorphize/src/errors.rs index fa7655f2624..c53ef20c7f8 100644 --- a/compiler/rustc_monomorphize/src/errors.rs +++ b/compiler/rustc_monomorphize/src/errors.rs @@ -3,7 +3,6 @@ use std::path::PathBuf; use rustc_errors::ErrorGuaranteed; use rustc_macros::{LintDiagnostic, SessionDiagnostic}; use rustc_session::SessionDiagnostic; -// use rustc_session::SessionDiagnostic; use rustc_span::Span; #[derive(SessionDiagnostic)] -- cgit 1.4.1-3-g733a5 From 30c750665517756484b0154b1b33a1256e614e6b Mon Sep 17 00:00:00 2001 From: Nathan Stocks Date: Wed, 24 Aug 2022 16:28:56 -0600 Subject: allow non-monomorphize modules to access hard-coded error message through new struct, use fluent message in monomorphize --- compiler/rustc_error_messages/locales/en-US/monomorphize.ftl | 3 +++ compiler/rustc_hir/src/errors.rs | 9 +++++++++ compiler/rustc_hir/src/lang_items.rs | 7 ++++--- compiler/rustc_hir/src/lib.rs | 1 + compiler/rustc_middle/src/middle/lang_items.rs | 6 +++--- compiler/rustc_monomorphize/src/collector.rs | 8 +++++--- compiler/rustc_monomorphize/src/errors.rs | 6 +++--- compiler/rustc_typeck/src/coherence/builtin.rs | 2 +- 8 files changed, 29 insertions(+), 13 deletions(-) create mode 100644 compiler/rustc_hir/src/errors.rs (limited to 'compiler/rustc_monomorphize/src/errors.rs') diff --git a/compiler/rustc_error_messages/locales/en-US/monomorphize.ftl b/compiler/rustc_error_messages/locales/en-US/monomorphize.ftl index 48ddb54b79e..42c84fdd2d1 100644 --- a/compiler/rustc_error_messages/locales/en-US/monomorphize.ftl +++ b/compiler/rustc_error_messages/locales/en-US/monomorphize.ftl @@ -21,3 +21,6 @@ monomorphize_large_assignments = moving {$size} bytes .label = value moved from here .note = The current maximum size is {$limit}, but it can be customized with the move_size_limit attribute: `#![move_size_limit = "..."]` + +monomorphize_requires_lang_item = + requires `{$lang_item}` lang_item diff --git a/compiler/rustc_hir/src/errors.rs b/compiler/rustc_hir/src/errors.rs new file mode 100644 index 00000000000..7ed09d3f293 --- /dev/null +++ b/compiler/rustc_hir/src/errors.rs @@ -0,0 +1,9 @@ +use crate::LangItem; + +pub struct LangItemError(pub LangItem); + +impl ToString for LangItemError { + fn to_string(&self) -> String { + format!("requires `{}` lang_item", self.0.name()) + } +} diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs index c337be12ae4..0c01326d003 100644 --- a/compiler/rustc_hir/src/lang_items.rs +++ b/compiler/rustc_hir/src/lang_items.rs @@ -8,6 +8,7 @@ //! * Functions called by the compiler itself. use crate::def_id::DefId; +use crate::errors::LangItemError; use crate::{MethodKind, Target}; use rustc_ast as ast; @@ -115,9 +116,9 @@ macro_rules! language_item_table { /// Requires that a given `LangItem` was bound and returns the corresponding `DefId`. /// If it wasn't bound, e.g. due to a missing `#[lang = ""]`, - /// returns an error message as a string. - pub fn require(&self, it: LangItem) -> Result { - self.items[it as usize].ok_or_else(|| format!("requires `{}` lang_item", it.name())) + /// returns an error encapsulating the `LangItem`. + pub fn require(&self, it: LangItem) -> Result { + self.items[it as usize].ok_or_else(|| LangItemError(it)) } /// Returns the [`DefId`]s of all lang items in a group. diff --git a/compiler/rustc_hir/src/lib.rs b/compiler/rustc_hir/src/lib.rs index 7097f998beb..092029ef09e 100644 --- a/compiler/rustc_hir/src/lib.rs +++ b/compiler/rustc_hir/src/lib.rs @@ -27,6 +27,7 @@ pub mod def; pub mod def_path_hash_map; pub mod definitions; pub mod diagnostic_items; +pub mod errors; pub use rustc_span::def_id; mod hir; pub mod hir_id; diff --git a/compiler/rustc_middle/src/middle/lang_items.rs b/compiler/rustc_middle/src/middle/lang_items.rs index cc9706f2d86..31c20fa14aa 100644 --- a/compiler/rustc_middle/src/middle/lang_items.rs +++ b/compiler/rustc_middle/src/middle/lang_items.rs @@ -18,11 +18,11 @@ impl<'tcx> TyCtxt<'tcx> { /// Returns the `DefId` for a given `LangItem`. /// If not found, fatally aborts compilation. pub fn require_lang_item(self, lang_item: LangItem, span: Option) -> DefId { - self.lang_items().require(lang_item).unwrap_or_else(|msg| { + self.lang_items().require(lang_item).unwrap_or_else(|err| { if let Some(span) = span { - self.sess.span_fatal(span, &msg) + self.sess.span_fatal(span, err.to_string()) } else { - self.sess.fatal(&msg) + self.sess.fatal(err.to_string()) } }) } diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs index 8f0d98563af..e0a14738b95 100644 --- a/compiler/rustc_monomorphize/src/collector.rs +++ b/compiler/rustc_monomorphize/src/collector.rs @@ -207,7 +207,7 @@ use std::iter; use std::ops::Range; use std::path::PathBuf; -use crate::errors::{FatalError, LargeAssignmentsLint, RecursionLimit, TypeLengthLimit}; +use crate::errors::{LargeAssignmentsLint, RecursionLimit, RequiresLangItem, TypeLengthLimit}; #[derive(PartialEq)] pub enum MonoItemCollectionMode { @@ -1328,8 +1328,10 @@ impl<'v> RootCollector<'_, 'v> { let start_def_id = match self.tcx.lang_items().require(LangItem::Start) { Ok(s) => s, - Err(error_message) => { - self.tcx.sess.emit_fatal(FatalError { error_message: error_message.clone() }); + Err(lang_item_err) => { + self.tcx + .sess + .emit_fatal(RequiresLangItem { lang_item: lang_item_err.0.name().to_string() }); } }; let main_ret_ty = self.tcx.fn_sig(main_def_id).output(); diff --git a/compiler/rustc_monomorphize/src/errors.rs b/compiler/rustc_monomorphize/src/errors.rs index c53ef20c7f8..77b6cfa1f69 100644 --- a/compiler/rustc_monomorphize/src/errors.rs +++ b/compiler/rustc_monomorphize/src/errors.rs @@ -33,9 +33,9 @@ pub struct TypeLengthLimit { } #[derive(SessionDiagnostic)] -#[diag(monomorphize::fatal_error)] -pub struct FatalError { - pub error_message: String, +#[diag(monomorphize::requires_lang_item)] +pub struct RequiresLangItem { + pub lang_item: String, } pub struct UnusedGenericParams { diff --git a/compiler/rustc_typeck/src/coherence/builtin.rs b/compiler/rustc_typeck/src/coherence/builtin.rs index 2467a81638f..d08c0d4dbb7 100644 --- a/compiler/rustc_typeck/src/coherence/builtin.rs +++ b/compiler/rustc_typeck/src/coherence/builtin.rs @@ -359,7 +359,7 @@ pub fn coerce_unsized_info<'tcx>(tcx: TyCtxt<'tcx>, impl_did: DefId) -> CoerceUn let coerce_unsized_trait = tcx.require_lang_item(LangItem::CoerceUnsized, Some(span)); let unsize_trait = tcx.lang_items().require(LangItem::Unsize).unwrap_or_else(|err| { - tcx.sess.fatal(&format!("`CoerceUnsized` implementation {}", err)); + tcx.sess.fatal(&format!("`CoerceUnsized` implementation {}", err.to_string())); }); let source = tcx.type_of(impl_did); -- cgit 1.4.1-3-g733a5