[rustc.git] / compiler / rustc_errors / src / diagnostic_impls.rs

use crate::fluent_generated as fluent;
use crate::{DiagnosticArgValue, DiagnosticBuilder, Handler, IntoDiagnostic, IntoDiagnosticArg};
use rustc_ast as ast;
use rustc_ast_pretty::pprust;
use rustc_hir as hir;
use rustc_lint_defs::Level;
use rustc_span::edition::Edition;
use rustc_span::symbol::{Ident, MacroRulesNormalizedIdent, Symbol};
use rustc_target::abi::TargetDataLayoutErrors;
use rustc_target::spec::{PanicStrategy, SplitDebuginfo, StackProtector, TargetTriple};
use rustc_type_ir as type_ir;
use std::borrow::Cow;
use std::fmt;
use std::num::ParseIntError;
use std::path::{Path, PathBuf};
use std::process::ExitStatus;

pub struct DiagnosticArgFromDisplay<'a>(pub &'a dyn fmt::Display);

impl IntoDiagnosticArg for DiagnosticArgFromDisplay<'_> {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        self.0.to_string().into_diagnostic_arg()
    }
}

impl<'a> From<&'a dyn fmt::Display> for DiagnosticArgFromDisplay<'a> {
    fn from(t: &'a dyn fmt::Display) -> Self {
        DiagnosticArgFromDisplay(t)
    }
}

impl<'a, T: fmt::Display> From<&'a T> for DiagnosticArgFromDisplay<'a> {
    fn from(t: &'a T) -> Self {
        DiagnosticArgFromDisplay(t)
    }
}

impl<'a, T: Clone + IntoDiagnosticArg> IntoDiagnosticArg for &'a T {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        self.clone().into_diagnostic_arg()
    }
}

macro_rules! into_diagnostic_arg_using_display {
    ($( $ty:ty ),+ $(,)?) => {
        $(
            impl IntoDiagnosticArg for $ty {
                fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
                    self.to_string().into_diagnostic_arg()
                }
            }
        )+
    }
}

into_diagnostic_arg_using_display!(
    ast::ParamKindOrd,
    i8,
    u8,
    i16,
    u16,
    i32,
    u32,
    i64,
    u64,
    i128,
    u128,
    std::io::Error,
    Box<dyn std::error::Error>,
    std::num::NonZeroU32,
    hir::Target,
    Edition,
    Ident,
    MacroRulesNormalizedIdent,
    ParseIntError,
    StackProtector,
    &TargetTriple,
    SplitDebuginfo,
    ExitStatus,
);

impl IntoDiagnosticArg for bool {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        if self {
            DiagnosticArgValue::Str(Cow::Borrowed("true"))
        } else {
            DiagnosticArgValue::Str(Cow::Borrowed("false"))
        }
    }
}

impl IntoDiagnosticArg for char {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Owned(format!("{:?}", self)))
    }
}

impl IntoDiagnosticArg for Symbol {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        self.to_ident_string().into_diagnostic_arg()
    }
}

impl<'a> IntoDiagnosticArg for &'a str {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        self.to_string().into_diagnostic_arg()
    }
}

impl IntoDiagnosticArg for String {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Owned(self))
    }
}

impl<'a> IntoDiagnosticArg for Cow<'a, str> {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Owned(self.into_owned()))
    }
}

impl<'a> IntoDiagnosticArg for &'a Path {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Owned(self.display().to_string()))
    }
}

impl IntoDiagnosticArg for PathBuf {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Owned(self.display().to_string()))
    }
}

impl IntoDiagnosticArg for usize {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Number(self)
    }
}

impl IntoDiagnosticArg for PanicStrategy {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Owned(self.desc().to_string()))
    }
}

impl IntoDiagnosticArg for hir::ConstContext {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Borrowed(match self {
            hir::ConstContext::ConstFn => "constant function",
            hir::ConstContext::Static(_) => "static",
            hir::ConstContext::Const => "constant",
        }))
    }
}

impl IntoDiagnosticArg for ast::Path {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Owned(pprust::path_to_string(&self)))
    }
}

impl IntoDiagnosticArg for ast::token::Token {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(pprust::token_to_string(&self))
    }
}

impl IntoDiagnosticArg for ast::token::TokenKind {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(pprust::token_kind_to_string(&self))
    }
}

impl IntoDiagnosticArg for type_ir::FloatTy {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Borrowed(self.name_str()))
    }
}

impl IntoDiagnosticArg for std::ffi::CString {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Owned(self.to_string_lossy().into_owned()))
    }
}

impl IntoDiagnosticArg for rustc_data_structures::small_c_str::SmallCStr {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Owned(self.to_string_lossy().into_owned()))
    }
}

impl IntoDiagnosticArg for ast::Visibility {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        let s = pprust::vis_to_string(&self);
        let s = s.trim_end().to_string();
        DiagnosticArgValue::Str(Cow::Owned(s))
    }
}

impl IntoDiagnosticArg for Level {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Borrowed(self.to_cmd_flag()))
    }
}

#[derive(Clone)]
pub struct DiagnosticSymbolList(Vec<Symbol>);

impl From<Vec<Symbol>> for DiagnosticSymbolList {
    fn from(v: Vec<Symbol>) -> Self {
        DiagnosticSymbolList(v)
    }
}

impl IntoDiagnosticArg for DiagnosticSymbolList {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::StrListSepByAnd(
            self.0.into_iter().map(|sym| Cow::Owned(format!("`{sym}`"))).collect(),
        )
    }
}

impl<Id> IntoDiagnosticArg for hir::def::Res<Id> {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        DiagnosticArgValue::Str(Cow::Borrowed(self.descr()))
    }
}

impl IntoDiagnostic<'_, !> for TargetDataLayoutErrors<'_> {
    fn into_diagnostic(self, handler: &Handler) -> DiagnosticBuilder<'_, !> {
        let mut diag;
        match self {
            TargetDataLayoutErrors::InvalidAddressSpace { addr_space, err, cause } => {
                diag = handler.struct_fatal(fluent::errors_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 = handler.struct_fatal(fluent::errors_target_invalid_bits);
                diag.set_arg("kind", kind);
                diag.set_arg("bit", bit);
                diag.set_arg("cause", cause);
                diag.set_arg("err", err);
                diag
            }
            TargetDataLayoutErrors::MissingAlignment { cause } => {
                diag = handler.struct_fatal(fluent::errors_target_missing_alignment);
                diag.set_arg("cause", cause);
                diag
            }
            TargetDataLayoutErrors::InvalidAlignment { cause, err } => {
                diag = handler.struct_fatal(fluent::errors_target_invalid_alignment);
                diag.set_arg("cause", cause);
                diag.set_arg("err", err);
                diag
            }
            TargetDataLayoutErrors::InconsistentTargetArchitecture { dl, target } => {
                diag = handler.struct_fatal(fluent::errors_target_inconsistent_architecture);
                diag.set_arg("dl", dl);
                diag.set_arg("target", target);
                diag
            }
            TargetDataLayoutErrors::InconsistentTargetPointerWidth { pointer_size, target } => {
                diag = handler.struct_fatal(fluent::errors_target_inconsistent_pointer_width);
                diag.set_arg("pointer_size", pointer_size);
                diag.set_arg("target", target);
                diag
            }
            TargetDataLayoutErrors::InvalidBitsSize { err } => {
                diag = handler.struct_fatal(fluent::errors_target_invalid_bits_size);
                diag.set_arg("err", err);
                diag
            }
        }
    }
}
Commit	Line	Data
9ffffee4 FG	1	use crate::fluent_generated as fluent;
9ffffee4 FG	2	use crate::{DiagnosticArgValue, DiagnosticBuilder, Handler, IntoDiagnostic, IntoDiagnosticArg};
2b03887a FG	3	use rustc_ast as ast;
	4	use rustc_ast_pretty::pprust;
	5	use rustc_hir as hir;
	6	use rustc_lint_defs::Level;
	7	use rustc_span::edition::Edition;
	8	use rustc_span::symbol::{Ident, MacroRulesNormalizedIdent, Symbol};
	9	use rustc_target::abi::TargetDataLayoutErrors;
	10	use rustc_target::spec::{PanicStrategy, SplitDebuginfo, StackProtector, TargetTriple};
9c376795	11	use rustc_type_ir as type_ir;
2b03887a FG	12	use std::borrow::Cow;
	13	use std::fmt;
	14	use std::num::ParseIntError;
	15	use std::path::{Path, PathBuf};
487cf647	16	use std::process::ExitStatus;
2b03887a FG	17
	18	pub struct DiagnosticArgFromDisplay<'a>(pub &'a dyn fmt::Display);
	19
	20	impl IntoDiagnosticArg for DiagnosticArgFromDisplay<'_> {
	21	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	22	self.0.to_string().into_diagnostic_arg()
	23	}
	24	}
	25
	26	impl<'a> From<&'a dyn fmt::Display> for DiagnosticArgFromDisplay<'a> {
	27	fn from(t: &'a dyn fmt::Display) -> Self {
	28	DiagnosticArgFromDisplay(t)
	29	}
	30	}
	31
	32	impl<'a, T: fmt::Display> From<&'a T> for DiagnosticArgFromDisplay<'a> {
	33	fn from(t: &'a T) -> Self {
	34	DiagnosticArgFromDisplay(t)
	35	}
	36	}
	37
9ffffee4 FG	38	impl<'a, T: Clone + IntoDiagnosticArg> IntoDiagnosticArg for &'a T {
	39	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	40	self.clone().into_diagnostic_arg()
	41	}
	42	}
	43
2b03887a FG	44	macro_rules! into_diagnostic_arg_using_display {
	45	($( $ty:ty ),+ $(,)?) => {
	46	$(
	47	impl IntoDiagnosticArg for $ty {
	48	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	49	self.to_string().into_diagnostic_arg()
	50	}
	51	}
	52	)+
	53	}
	54	}
	55
	56	into_diagnostic_arg_using_display!(
9ffffee4	57	ast::ParamKindOrd,
2b03887a FG	58	i8,
	59	u8,
	60	i16,
	61	u16,
	62	i32,
	63	u32,
	64	i64,
	65	u64,
	66	i128,
	67	u128,
	68	std::io::Error,
9c376795	69	Box<dyn std::error::Error>,
2b03887a FG	70	std::num::NonZeroU32,
	71	hir::Target,
	72	Edition,
	73	Ident,
	74	MacroRulesNormalizedIdent,
	75	ParseIntError,
	76	StackProtector,
	77	&TargetTriple,
487cf647 FG	78	SplitDebuginfo,
487cf647 FG	79	ExitStatus,
2b03887a FG	80	);
	81
	82	impl IntoDiagnosticArg for bool {
	83	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	84	if self {
	85	DiagnosticArgValue::Str(Cow::Borrowed("true"))
	86	} else {
	87	DiagnosticArgValue::Str(Cow::Borrowed("false"))
	88	}
	89	}
	90	}
	91
	92	impl IntoDiagnosticArg for char {
	93	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	94	DiagnosticArgValue::Str(Cow::Owned(format!("{:?}", self)))
	95	}
	96	}
	97
	98	impl IntoDiagnosticArg for Symbol {
	99	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	100	self.to_ident_string().into_diagnostic_arg()
	101	}
	102	}
	103
	104	impl<'a> IntoDiagnosticArg for &'a str {
	105	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	106	self.to_string().into_diagnostic_arg()
	107	}
	108	}
	109
	110	impl IntoDiagnosticArg for String {
	111	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	112	DiagnosticArgValue::Str(Cow::Owned(self))
	113	}
	114	}
	115
487cf647 FG	116	impl<'a> IntoDiagnosticArg for Cow<'a, str> {
	117	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	118	DiagnosticArgValue::Str(Cow::Owned(self.into_owned()))
	119	}
	120	}
	121
2b03887a FG	122	impl<'a> IntoDiagnosticArg for &'a Path {
	123	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	124	DiagnosticArgValue::Str(Cow::Owned(self.display().to_string()))
	125	}
	126	}
	127
	128	impl IntoDiagnosticArg for PathBuf {
	129	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	130	DiagnosticArgValue::Str(Cow::Owned(self.display().to_string()))
	131	}
	132	}
	133
	134	impl IntoDiagnosticArg for usize {
	135	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	136	DiagnosticArgValue::Number(self)
	137	}
	138	}
	139
	140	impl IntoDiagnosticArg for PanicStrategy {
	141	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	142	DiagnosticArgValue::Str(Cow::Owned(self.desc().to_string()))
	143	}
	144	}
	145
	146	impl IntoDiagnosticArg for hir::ConstContext {
	147	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	148	DiagnosticArgValue::Str(Cow::Borrowed(match self {
	149	hir::ConstContext::ConstFn => "constant function",
	150	hir::ConstContext::Static(_) => "static",
	151	hir::ConstContext::Const => "constant",
	152	}))
	153	}
	154	}
	155
	156	impl IntoDiagnosticArg for ast::Path {
	157	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	158	DiagnosticArgValue::Str(Cow::Owned(pprust::path_to_string(&self)))
	159	}
	160	}
	161
	162	impl IntoDiagnosticArg for ast::token::Token {
	163	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	164	DiagnosticArgValue::Str(pprust::token_to_string(&self))
	165	}
	166	}
	167
	168	impl IntoDiagnosticArg for ast::token::TokenKind {
	169	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	170	DiagnosticArgValue::Str(pprust::token_kind_to_string(&self))
	171	}
	172	}
	173
9c376795 FG	174	impl IntoDiagnosticArg for type_ir::FloatTy {
	175	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	176	DiagnosticArgValue::Str(Cow::Borrowed(self.name_str()))
	177	}
	178	}
	179
9ffffee4 FG	180	impl IntoDiagnosticArg for std::ffi::CString {
	181	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	182	DiagnosticArgValue::Str(Cow::Owned(self.to_string_lossy().into_owned()))
	183	}
	184	}
	185
	186	impl IntoDiagnosticArg for rustc_data_structures::small_c_str::SmallCStr {
	187	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	188	DiagnosticArgValue::Str(Cow::Owned(self.to_string_lossy().into_owned()))
	189	}
	190	}
	191
	192	impl IntoDiagnosticArg for ast::Visibility {
	193	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	194	let s = pprust::vis_to_string(&self);
	195	let s = s.trim_end().to_string();
	196	DiagnosticArgValue::Str(Cow::Owned(s))
	197	}
	198	}
	199
2b03887a FG	200	impl IntoDiagnosticArg for Level {
2b03887a FG	201	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
9c376795	202	DiagnosticArgValue::Str(Cow::Borrowed(self.to_cmd_flag()))
2b03887a FG	203	}
	204	}
	205
487cf647 FG	206	#[derive(Clone)]
	207	pub struct DiagnosticSymbolList(Vec<Symbol>);
	208
	209	impl From<Vec<Symbol>> for DiagnosticSymbolList {
	210	fn from(v: Vec<Symbol>) -> Self {
	211	DiagnosticSymbolList(v)
	212	}
	213	}
	214
	215	impl IntoDiagnosticArg for DiagnosticSymbolList {
	216	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	217	DiagnosticArgValue::StrListSepByAnd(
	218	self.0.into_iter().map(\|sym\| Cow::Owned(format!("`{sym}`"))).collect(),
	219	)
	220	}
	221	}
	222
	223	impl<Id> IntoDiagnosticArg for hir::def::Res<Id> {
	224	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	225	DiagnosticArgValue::Str(Cow::Borrowed(self.descr()))
	226	}
	227	}
	228
2b03887a FG	229	impl IntoDiagnostic<'_, !> for TargetDataLayoutErrors<'_> {
	230	fn into_diagnostic(self, handler: &Handler) -> DiagnosticBuilder<'_, !> {
	231	let mut diag;
	232	match self {
	233	TargetDataLayoutErrors::InvalidAddressSpace { addr_space, err, cause } => {
	234	diag = handler.struct_fatal(fluent::errors_target_invalid_address_space);
	235	diag.set_arg("addr_space", addr_space);
	236	diag.set_arg("cause", cause);
	237	diag.set_arg("err", err);
	238	diag
	239	}
	240	TargetDataLayoutErrors::InvalidBits { kind, bit, cause, err } => {
	241	diag = handler.struct_fatal(fluent::errors_target_invalid_bits);
	242	diag.set_arg("kind", kind);
	243	diag.set_arg("bit", bit);
	244	diag.set_arg("cause", cause);
	245	diag.set_arg("err", err);
	246	diag
	247	}
	248	TargetDataLayoutErrors::MissingAlignment { cause } => {
	249	diag = handler.struct_fatal(fluent::errors_target_missing_alignment);
	250	diag.set_arg("cause", cause);
	251	diag
	252	}
	253	TargetDataLayoutErrors::InvalidAlignment { cause, err } => {
	254	diag = handler.struct_fatal(fluent::errors_target_invalid_alignment);
	255	diag.set_arg("cause", cause);
	256	diag.set_arg("err", err);
	257	diag
	258	}
	259	TargetDataLayoutErrors::InconsistentTargetArchitecture { dl, target } => {
	260	diag = handler.struct_fatal(fluent::errors_target_inconsistent_architecture);
	261	diag.set_arg("dl", dl);
	262	diag.set_arg("target", target);
	263	diag
	264	}
	265	TargetDataLayoutErrors::InconsistentTargetPointerWidth { pointer_size, target } => {
	266	diag = handler.struct_fatal(fluent::errors_target_inconsistent_pointer_width);
	267	diag.set_arg("pointer_size", pointer_size);
	268	diag.set_arg("target", target);
	269	diag
	270	}
	271	TargetDataLayoutErrors::InvalidBitsSize { err } => {
	272	diag = handler.struct_fatal(fluent::errors_target_invalid_bits_size);
	273	diag.set_arg("err", err);
	274	diag
	275	}
	276	}
	277	}
	278	}