1 use rustc_ast::{MetaItem, NestedMetaItem};
2 use rustc_attr as attr;
3 use rustc_data_structures::fx::FxHashMap;
4 use rustc_errors::{struct_span_err, ErrorGuaranteed};
5 use rustc_hir::def_id::DefId;
6 use rustc_middle::ty::{self, GenericParamDefKind, TyCtxt};
7 use rustc_parse_format::{ParseMode, Parser, Piece, Position};
8 use rustc_span::symbol::{kw, sym, Symbol};
9 use rustc_span::{Span, DUMMY_SP};
12 EmptyOnClauseInOnUnimplemented, InvalidOnClauseInOnUnimplemented, NoValueInOnUnimplemented,
15 #[derive(Clone, Debug)]
16 pub struct OnUnimplementedFormatString(Symbol);
19 pub struct OnUnimplementedDirective {
20 pub condition: Option<MetaItem>,
21 pub subcommands: Vec<OnUnimplementedDirective>,
22 pub message: Option<OnUnimplementedFormatString>,
23 pub label: Option<OnUnimplementedFormatString>,
24 pub note: Option<OnUnimplementedFormatString>,
25 pub parent_label: Option<OnUnimplementedFormatString>,
26 pub append_const_msg: Option<Option<Symbol>>,
30 pub struct OnUnimplementedNote {
31 pub message: Option<String>,
32 pub label: Option<String>,
33 pub note: Option<String>,
34 pub parent_label: Option<String>,
35 /// Append a message for `~const Trait` errors. `None` means not requested and
36 /// should fallback to a generic message, `Some(None)` suggests using the default
37 /// appended message, `Some(Some(s))` suggests use the `s` message instead of the
39 pub append_const_msg: Option<Option<Symbol>>,
42 impl<'tcx> OnUnimplementedDirective {
46 items: &[NestedMetaItem],
49 ) -> Result<Self, ErrorGuaranteed> {
50 let mut errored = None;
51 let mut item_iter = items.iter();
53 let parse_value = |value_str| {
54 OnUnimplementedFormatString::try_parse(tcx, item_def_id, value_str, span).map(Some)
57 let condition = if is_root {
62 .ok_or_else(|| tcx.sess.emit_err(EmptyOnClauseInOnUnimplemented { span }))?
64 .ok_or_else(|| tcx.sess.emit_err(InvalidOnClauseInOnUnimplemented { span }))?;
65 attr::eval_condition(cond, &tcx.sess.parse_sess, Some(tcx.features()), &mut |cfg| {
66 if let Some(value) = cfg.value && let Err(guar) = parse_value(value) {
74 let mut message = None;
77 let mut parent_label = None;
78 let mut subcommands = vec![];
79 let mut append_const_msg = None;
81 for item in item_iter {
82 if item.has_name(sym::message) && message.is_none() {
83 if let Some(message_) = item.value_str() {
84 message = parse_value(message_)?;
87 } else if item.has_name(sym::label) && label.is_none() {
88 if let Some(label_) = item.value_str() {
89 label = parse_value(label_)?;
92 } else if item.has_name(sym::note) && note.is_none() {
93 if let Some(note_) = item.value_str() {
94 note = parse_value(note_)?;
97 } else if item.has_name(sym::parent_label) && parent_label.is_none() {
98 if let Some(parent_label_) = item.value_str() {
99 parent_label = parse_value(parent_label_)?;
102 } else if item.has_name(sym::on)
108 if let Some(items) = item.meta_item_list() {
109 match Self::parse(tcx, item_def_id, &items, item.span(), false) {
110 Ok(subcommand) => subcommands.push(subcommand),
111 Err(reported) => errored = Some(reported),
115 } else if item.has_name(sym::append_const_msg) && append_const_msg.is_none() {
116 if let Some(msg) = item.value_str() {
117 append_const_msg = Some(Some(msg));
119 } else if item.is_word() {
120 append_const_msg = Some(None);
126 tcx.sess.emit_err(NoValueInOnUnimplemented { span: item.span() });
129 if let Some(reported) = errored {
132 Ok(OnUnimplementedDirective {
144 pub fn of_item(tcx: TyCtxt<'tcx>, item_def_id: DefId) -> Result<Option<Self>, ErrorGuaranteed> {
145 let Some(attr) = tcx.get_attr(item_def_id, sym::rustc_on_unimplemented) else {
149 let result = if let Some(items) = attr.meta_item_list() {
150 Self::parse(tcx, item_def_id, &items, attr.span, true).map(Some)
151 } else if let Some(value) = attr.value_str() {
152 Ok(Some(OnUnimplementedDirective {
156 label: Some(OnUnimplementedFormatString::try_parse(
164 append_const_msg: None,
168 tcx.sess.delay_span_bug(DUMMY_SP, "of_item: neither meta_item_list nor value_str");
169 return Err(reported);
171 debug!("of_item({:?}) = {:?}", item_def_id, result);
178 trait_ref: ty::TraitRef<'tcx>,
179 options: &[(Symbol, Option<String>)],
180 ) -> OnUnimplementedNote {
181 let mut message = None;
182 let mut label = None;
184 let mut parent_label = None;
185 let mut append_const_msg = None;
186 info!("evaluate({:?}, trait_ref={:?}, options={:?})", self, trait_ref, options);
188 let options_map: FxHashMap<Symbol, String> =
189 options.iter().filter_map(|(k, v)| v.as_ref().map(|v| (*k, v.to_owned()))).collect();
191 for command in self.subcommands.iter().chain(Some(self)).rev() {
192 if let Some(ref condition) = command.condition && !attr::eval_condition(
194 &tcx.sess.parse_sess,
195 Some(tcx.features()),
197 let value = cfg.value.map(|v| {
198 OnUnimplementedFormatString(v).format(tcx, trait_ref, &options_map)
201 options.contains(&(cfg.name, value))
204 debug!("evaluate: skipping {:?} due to condition", command);
207 debug!("evaluate: {:?} succeeded", command);
208 if let Some(ref message_) = command.message {
209 message = Some(message_.clone());
212 if let Some(ref label_) = command.label {
213 label = Some(label_.clone());
216 if let Some(ref note_) = command.note {
217 note = Some(note_.clone());
220 if let Some(ref parent_label_) = command.parent_label {
221 parent_label = Some(parent_label_.clone());
224 append_const_msg = command.append_const_msg;
227 OnUnimplementedNote {
228 label: label.map(|l| l.format(tcx, trait_ref, &options_map)),
229 message: message.map(|m| m.format(tcx, trait_ref, &options_map)),
230 note: note.map(|n| n.format(tcx, trait_ref, &options_map)),
231 parent_label: parent_label.map(|e_s| e_s.format(tcx, trait_ref, &options_map)),
237 impl<'tcx> OnUnimplementedFormatString {
243 ) -> Result<Self, ErrorGuaranteed> {
244 let result = OnUnimplementedFormatString(from);
245 result.verify(tcx, item_def_id, err_sp)?;
254 ) -> Result<(), ErrorGuaranteed> {
255 let trait_def_id = if tcx.is_trait(item_def_id) {
258 tcx.trait_id_of_impl(item_def_id)
259 .expect("expected `on_unimplemented` to correspond to a trait")
261 let trait_name = tcx.item_name(trait_def_id);
262 let generics = tcx.generics_of(item_def_id);
263 let s = self.0.as_str();
264 let parser = Parser::new(s, None, None, false, ParseMode::Format);
265 let mut result = Ok(());
266 for token in parser {
268 Piece::String(_) => (), // Normal string, no need to check it
269 Piece::NextArgument(a) => match a.position {
270 Position::ArgumentNamed(s) => {
271 match Symbol::intern(s) {
272 // `{Self}` is allowed
274 // `{ThisTraitsName}` is allowed
275 s if s == trait_name => (),
276 // `{from_method}` is allowed
277 sym::from_method => (),
278 // `{from_desugaring}` is allowed
279 sym::from_desugaring => (),
280 // `{ItemContext}` is allowed
281 sym::ItemContext => (),
282 // `{integral}` and `{integer}` and `{float}` are allowed
283 sym::integral | sym::integer_ | sym::float => (),
284 // So is `{A}` if A is a type parameter
285 s => match generics.params.iter().find(|param| param.name == s) {
288 let reported = struct_span_err!(
292 "there is no parameter `{}` on {}",
294 if trait_def_id == item_def_id {
295 format!("trait `{}`", trait_name)
301 result = Err(reported);
306 // `{:1}` and `{}` are not to be used
307 Position::ArgumentIs(..) | Position::ArgumentImplicitlyIs(_) => {
308 let reported = struct_span_err!(
312 "only named substitution parameters are allowed"
315 result = Err(reported);
327 trait_ref: ty::TraitRef<'tcx>,
328 options: &FxHashMap<Symbol, String>,
330 let name = tcx.item_name(trait_ref.def_id);
331 let trait_str = tcx.def_path_str(trait_ref.def_id);
332 let generics = tcx.generics_of(trait_ref.def_id);
333 let generic_map = generics
336 .filter_map(|param| {
337 let value = match param.kind {
338 GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {
339 trait_ref.substs[param.index as usize].to_string()
341 GenericParamDefKind::Lifetime => return None,
343 let name = param.name;
346 .collect::<FxHashMap<Symbol, String>>();
347 let empty_string = String::new();
349 let s = self.0.as_str();
350 let parser = Parser::new(s, None, None, false, ParseMode::Format);
351 let item_context = (options.get(&sym::ItemContext)).unwrap_or(&empty_string);
354 Piece::String(s) => s,
355 Piece::NextArgument(a) => match a.position {
356 Position::ArgumentNamed(s) => {
357 let s = Symbol::intern(s);
358 match generic_map.get(&s) {
360 None if s == name => &trait_str,
362 if let Some(val) = options.get(&s) {
364 } else if s == sym::from_desugaring || s == sym::from_method {
365 // don't break messages using these two arguments incorrectly
367 } else if s == sym::ItemContext {
369 } else if s == sym::integral {
371 } else if s == sym::integer_ {
373 } else if s == sym::float {
377 "broken on_unimplemented {:?} for {:?}: \
378 no argument matching {:?}",
387 _ => bug!("broken on_unimplemented {:?} - bad format arg", self.0),