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};
11 #[derive(Clone, Debug)]
12 pub struct OnUnimplementedFormatString(Symbol);
15 pub struct OnUnimplementedDirective {
16 pub condition: Option<MetaItem>,
17 pub subcommands: Vec<OnUnimplementedDirective>,
18 pub message: Option<OnUnimplementedFormatString>,
19 pub label: Option<OnUnimplementedFormatString>,
20 pub note: Option<OnUnimplementedFormatString>,
21 pub enclosing_scope: Option<OnUnimplementedFormatString>,
22 pub append_const_msg: Option<Option<Symbol>>,
26 pub struct OnUnimplementedNote {
27 pub message: Option<String>,
28 pub label: Option<String>,
29 pub note: Option<String>,
30 pub enclosing_scope: Option<String>,
31 /// Append a message for `~const Trait` errors. `None` means not requested and
32 /// should fallback to a generic message, `Some(None)` suggests using the default
33 /// appended message, `Some(Some(s))` suggests use the `s` message instead of the
35 pub append_const_msg: Option<Option<Symbol>>,
44 ) -> ErrorGuaranteed {
45 let mut diag = struct_span_err!(tcx.sess, span, E0232, "{}", message);
46 diag.span_label(span, label);
47 if let Some(note) = note {
53 impl<'tcx> OnUnimplementedDirective {
57 items: &[NestedMetaItem],
60 ) -> Result<Self, ErrorGuaranteed> {
61 let mut errored = None;
62 let mut item_iter = items.iter();
64 let parse_value = |value_str| {
65 OnUnimplementedFormatString::try_parse(tcx, item_def_id, value_str, span).map(Some)
68 let condition = if is_root {
77 "empty `on`-clause in `#[rustc_on_unimplemented]`",
78 "empty on-clause here",
87 "invalid `on`-clause in `#[rustc_on_unimplemented]`",
88 "invalid on-clause here",
92 attr::eval_condition(cond, &tcx.sess.parse_sess, Some(tcx.features()), &mut |item| {
93 if let Some(symbol) = item.value_str() && let Err(guar) = parse_value(symbol) {
101 let mut message = None;
102 let mut label = None;
104 let mut enclosing_scope = None;
105 let mut subcommands = vec![];
106 let mut append_const_msg = None;
108 for item in item_iter {
109 if item.has_name(sym::message) && message.is_none() {
110 if let Some(message_) = item.value_str() {
111 message = parse_value(message_)?;
114 } else if item.has_name(sym::label) && label.is_none() {
115 if let Some(label_) = item.value_str() {
116 label = parse_value(label_)?;
119 } else if item.has_name(sym::note) && note.is_none() {
120 if let Some(note_) = item.value_str() {
121 note = parse_value(note_)?;
124 } else if item.has_name(sym::enclosing_scope) && enclosing_scope.is_none() {
125 if let Some(enclosing_scope_) = item.value_str() {
126 enclosing_scope = parse_value(enclosing_scope_)?;
129 } else if item.has_name(sym::on)
135 if let Some(items) = item.meta_item_list() {
136 match Self::parse(tcx, item_def_id, &items, item.span(), false) {
137 Ok(subcommand) => subcommands.push(subcommand),
138 Err(reported) => errored = Some(reported),
142 } else if item.has_name(sym::append_const_msg) && append_const_msg.is_none() {
143 if let Some(msg) = item.value_str() {
144 append_const_msg = Some(Some(msg));
146 } else if item.is_word() {
147 append_const_msg = Some(None);
156 "this attribute must have a valid value",
157 "expected value here",
158 Some(r#"eg `#[rustc_on_unimplemented(message="foo")]`"#),
162 if let Some(reported) = errored {
165 Ok(OnUnimplementedDirective {
177 pub fn of_item(tcx: TyCtxt<'tcx>, item_def_id: DefId) -> Result<Option<Self>, ErrorGuaranteed> {
178 let attrs = tcx.get_attrs(item_def_id);
180 let Some(attr) = tcx.sess.find_by_name(&attrs, sym::rustc_on_unimplemented) else {
184 let result = if let Some(items) = attr.meta_item_list() {
185 Self::parse(tcx, item_def_id, &items, attr.span, true).map(Some)
186 } else if let Some(value) = attr.value_str() {
187 Ok(Some(OnUnimplementedDirective {
191 label: Some(OnUnimplementedFormatString::try_parse(
198 enclosing_scope: None,
199 append_const_msg: None,
203 tcx.sess.delay_span_bug(DUMMY_SP, "of_item: neither meta_item_list nor value_str");
204 return Err(reported);
206 debug!("of_item({:?}) = {:?}", item_def_id, result);
213 trait_ref: ty::TraitRef<'tcx>,
214 options: &[(Symbol, Option<String>)],
215 ) -> OnUnimplementedNote {
216 let mut message = None;
217 let mut label = None;
219 let mut enclosing_scope = None;
220 let mut append_const_msg = None;
221 info!("evaluate({:?}, trait_ref={:?}, options={:?})", self, trait_ref, options);
223 let options_map: FxHashMap<Symbol, String> =
224 options.iter().filter_map(|(k, v)| v.as_ref().map(|v| (*k, v.to_owned()))).collect();
226 for command in self.subcommands.iter().chain(Some(self)).rev() {
227 if let Some(ref condition) = command.condition && !attr::eval_condition(
229 &tcx.sess.parse_sess,
230 Some(tcx.features()),
232 c.ident().map_or(false, |ident| {
233 let value = c.value_str().map(|s| {
234 OnUnimplementedFormatString(s).format(tcx, trait_ref, &options_map)
237 options.contains(&(ident.name, value))
241 debug!("evaluate: skipping {:?} due to condition", command);
244 debug!("evaluate: {:?} succeeded", command);
245 if let Some(ref message_) = command.message {
246 message = Some(message_.clone());
249 if let Some(ref label_) = command.label {
250 label = Some(label_.clone());
253 if let Some(ref note_) = command.note {
254 note = Some(note_.clone());
257 if let Some(ref enclosing_scope_) = command.enclosing_scope {
258 enclosing_scope = Some(enclosing_scope_.clone());
261 append_const_msg = command.append_const_msg;
264 OnUnimplementedNote {
265 label: label.map(|l| l.format(tcx, trait_ref, &options_map)),
266 message: message.map(|m| m.format(tcx, trait_ref, &options_map)),
267 note: note.map(|n| n.format(tcx, trait_ref, &options_map)),
268 enclosing_scope: enclosing_scope.map(|e_s| e_s.format(tcx, trait_ref, &options_map)),
274 impl<'tcx> OnUnimplementedFormatString {
280 ) -> Result<Self, ErrorGuaranteed> {
281 let result = OnUnimplementedFormatString(from);
282 result.verify(tcx, item_def_id, err_sp)?;
291 ) -> Result<(), ErrorGuaranteed> {
292 let trait_def_id = if tcx.is_trait(item_def_id) {
295 tcx.trait_id_of_impl(item_def_id)
296 .expect("expected `on_unimplemented` to correspond to a trait")
298 let trait_name = tcx.item_name(trait_def_id);
299 let generics = tcx.generics_of(item_def_id);
300 let s = self.0.as_str();
301 let parser = Parser::new(s, None, None, false, ParseMode::Format);
302 let mut result = Ok(());
303 for token in parser {
305 Piece::String(_) => (), // Normal string, no need to check it
306 Piece::NextArgument(a) => match a.position {
307 Position::ArgumentNamed(s, _) => {
308 match Symbol::intern(s) {
309 // `{Self}` is allowed
311 // `{ThisTraitsName}` is allowed
312 s if s == trait_name => (),
313 // `{from_method}` is allowed
314 sym::from_method => (),
315 // `{from_desugaring}` is allowed
316 sym::from_desugaring => (),
317 // `{ItemContext}` is allowed
318 sym::ItemContext => (),
319 // `{integral}` and `{integer}` and `{float}` are allowed
320 sym::integral | sym::integer_ | sym::float => (),
321 // So is `{A}` if A is a type parameter
322 s => match generics.params.iter().find(|param| param.name == s) {
325 let reported = struct_span_err!(
329 "there is no parameter `{}` on {}",
331 if trait_def_id == item_def_id {
332 format!("trait `{}`", trait_name)
338 result = Err(reported);
343 // `{:1}` and `{}` are not to be used
344 Position::ArgumentIs(_) | Position::ArgumentImplicitlyIs(_) => {
345 let reported = struct_span_err!(
349 "only named substitution parameters are allowed"
352 result = Err(reported);
364 trait_ref: ty::TraitRef<'tcx>,
365 options: &FxHashMap<Symbol, String>,
367 let name = tcx.item_name(trait_ref.def_id);
368 let trait_str = tcx.def_path_str(trait_ref.def_id);
369 let generics = tcx.generics_of(trait_ref.def_id);
370 let generic_map = generics
373 .filter_map(|param| {
374 let value = match param.kind {
375 GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {
376 trait_ref.substs[param.index as usize].to_string()
378 GenericParamDefKind::Lifetime => return None,
380 let name = param.name;
383 .collect::<FxHashMap<Symbol, String>>();
384 let empty_string = String::new();
386 let s = self.0.as_str();
387 let parser = Parser::new(s, None, None, false, ParseMode::Format);
388 let item_context = (options.get(&sym::ItemContext)).unwrap_or(&empty_string);
391 Piece::String(s) => s,
392 Piece::NextArgument(a) => match a.position {
393 Position::ArgumentNamed(s, _) => {
394 let s = Symbol::intern(s);
395 match generic_map.get(&s) {
397 None if s == name => &trait_str,
399 if let Some(val) = options.get(&s) {
401 } else if s == sym::from_desugaring || s == sym::from_method {
402 // don't break messages using these two arguments incorrectly
404 } else if s == sym::ItemContext {
406 } else if s == sym::integral {
408 } else if s == sym::integer_ {
410 } else if s == sym::float {
414 "broken on_unimplemented {:?} for {:?}: \
415 no argument matching {:?}",
424 _ => bug!("broken on_unimplemented {:?} - bad format arg", self.0),