compiler/rustc_trait_selection/src/traits/on_unimplemented.rs

   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, ErrorReported};
   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;
  10
  11 #[derive(Clone, Debug)]
  12 pub struct OnUnimplementedFormatString(Symbol);
  13
  14 #[derive(Debug)]
  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 }
  23
  24 #[derive(Default)]
  25 pub struct OnUnimplementedNote {
  26     pub message: Option<String>,
  27     pub label: Option<String>,
  28     pub note: Option<String>,
  29     pub enclosing_scope: Option<String>,
  30 }
  31
  32 fn parse_error(
  33     tcx: TyCtxt<'_>,
  34     span: Span,
  35     message: &str,
  36     label: &str,
  37     note: Option<&str>,
  38 ) -> ErrorReported {
  39     let mut diag = struct_span_err!(tcx.sess, span, E0232, "{}", message);
  40     diag.span_label(span, label);
  41     if let Some(note) = note {
  42         diag.note(note);
  43     }
  44     diag.emit();
  45     ErrorReported
  46 }
  47
  48 impl<'tcx> OnUnimplementedDirective {
  49     fn parse(
  50         tcx: TyCtxt<'tcx>,
  51         trait_def_id: DefId,
  52         items: &[NestedMetaItem],
  53         span: Span,
  54         is_root: bool,
  55     ) -> Result<Self, ErrorReported> {
  56         let mut errored = false;
  57         let mut item_iter = items.iter();
  58
  59         let condition = if is_root {
  60             None
  61         } else {
  62             let cond = item_iter
  63                 .next()
  64                 .ok_or_else(|| {
  65                     parse_error(
  66                         tcx,
  67                         span,
  68                         "empty `on`-clause in `#[rustc_on_unimplemented]`",
  69                         "empty on-clause here",
  70                         None,
  71                     )
  72                 })?
  73                 .meta_item()
  74                 .ok_or_else(|| {
  75                     parse_error(
  76                         tcx,
  77                         span,
  78                         "invalid `on`-clause in `#[rustc_on_unimplemented]`",
  79                         "invalid on-clause here",
  80                         None,
  81                     )
  82                 })?;
  83             attr::eval_condition(cond, &tcx.sess.parse_sess, Some(tcx.features()), &mut |_| true);
  84             Some(cond.clone())
  85         };
  86
  87         let mut message = None;
  88         let mut label = None;
  89         let mut note = None;
  90         let mut enclosing_scope = None;
  91         let mut subcommands = vec![];
  92
  93         let parse_value = |value_str| {
  94             OnUnimplementedFormatString::try_parse(tcx, trait_def_id, value_str, span).map(Some)
  95         };
  96
  97         for item in item_iter {
  98             if item.has_name(sym::message) && message.is_none() {
  99                 if let Some(message_) = item.value_str() {
 100                     message = parse_value(message_)?;
 101                     continue;
 102                 }
 103             } else if item.has_name(sym::label) && label.is_none() {
 104                 if let Some(label_) = item.value_str() {
 105                     label = parse_value(label_)?;
 106                     continue;
 107                 }
 108             } else if item.has_name(sym::note) && note.is_none() {
 109                 if let Some(note_) = item.value_str() {
 110                     note = parse_value(note_)?;
 111                     continue;
 112                 }
 113             } else if item.has_name(sym::enclosing_scope) && enclosing_scope.is_none() {
 114                 if let Some(enclosing_scope_) = item.value_str() {
 115                     enclosing_scope = parse_value(enclosing_scope_)?;
 116                     continue;
 117                 }
 118             } else if item.has_name(sym::on)
 119                 && is_root
 120                 && message.is_none()
 121                 && label.is_none()
 122                 && note.is_none()
 123             {
 124                 if let Some(items) = item.meta_item_list() {
 125                     if let Ok(subcommand) =
 126                         Self::parse(tcx, trait_def_id, &items, item.span(), false)
 127                     {
 128                         subcommands.push(subcommand);
 129                     } else {
 130                         errored = true;
 131                     }
 132                     continue;
 133                 }
 134             }
 135
 136             // nothing found
 137             parse_error(
 138                 tcx,
 139                 item.span(),
 140                 "this attribute must have a valid value",
 141                 "expected value here",
 142                 Some(r#"eg `#[rustc_on_unimplemented(message="foo")]`"#),
 143             );
 144         }
 145
 146         if errored {
 147             Err(ErrorReported)
 148         } else {
 149             Ok(OnUnimplementedDirective {
 150                 condition,
 151                 subcommands,
 152                 message,
 153                 label,
 154                 note,
 155                 enclosing_scope,
 156             })
 157         }
 158     }
 159
 160     pub fn of_item(
 161         tcx: TyCtxt<'tcx>,
 162         trait_def_id: DefId,
 163         impl_def_id: DefId,
 164     ) -> Result<Option<Self>, ErrorReported> {
 165         let attrs = tcx.get_attrs(impl_def_id);
 166
 167         let Some(attr) = tcx.sess.find_by_name(&attrs, sym::rustc_on_unimplemented) else {
 168             return Ok(None);
 169         };
 170
 171         let result = if let Some(items) = attr.meta_item_list() {
 172             Self::parse(tcx, trait_def_id, &items, attr.span, true).map(Some)
 173         } else if let Some(value) = attr.value_str() {
 174             Ok(Some(OnUnimplementedDirective {
 175                 condition: None,
 176                 message: None,
 177                 subcommands: vec![],
 178                 label: Some(OnUnimplementedFormatString::try_parse(
 179                     tcx,
 180                     trait_def_id,
 181                     value,
 182                     attr.span,
 183                 )?),
 184                 note: None,
 185                 enclosing_scope: None,
 186             }))
 187         } else {
 188             return Err(ErrorReported);
 189         };
 190         debug!("of_item({:?}/{:?}) = {:?}", trait_def_id, impl_def_id, result);
 191         result
 192     }
 193
 194     pub fn evaluate(
 195         &self,
 196         tcx: TyCtxt<'tcx>,
 197         trait_ref: ty::TraitRef<'tcx>,
 198         options: &[(Symbol, Option<String>)],
 199     ) -> OnUnimplementedNote {
 200         let mut message = None;
 201         let mut label = None;
 202         let mut note = None;
 203         let mut enclosing_scope = None;
 204         info!("evaluate({:?}, trait_ref={:?}, options={:?})", self, trait_ref, options);
 205
 206         for command in self.subcommands.iter().chain(Some(self)).rev() {
 207             if let Some(ref condition) = command.condition {
 208                 if !attr::eval_condition(
 209                     condition,
 210                     &tcx.sess.parse_sess,
 211                     Some(tcx.features()),
 212                     &mut |c| {
 213                         c.ident().map_or(false, |ident| {
 214                             options.contains(&(ident.name, c.value_str().map(|s| s.to_string())))
 215                         })
 216                     },
 217                 ) {
 218                     debug!("evaluate: skipping {:?} due to condition", command);
 219                     continue;
 220                 }
 221             }
 222             debug!("evaluate: {:?} succeeded", command);
 223             if let Some(ref message_) = command.message {
 224                 message = Some(message_.clone());
 225             }
 226
 227             if let Some(ref label_) = command.label {
 228                 label = Some(label_.clone());
 229             }
 230
 231             if let Some(ref note_) = command.note {
 232                 note = Some(note_.clone());
 233             }
 234
 235             if let Some(ref enclosing_scope_) = command.enclosing_scope {
 236                 enclosing_scope = Some(enclosing_scope_.clone());
 237             }
 238         }
 239
 240         let options: FxHashMap<Symbol, String> =
 241             options.iter().filter_map(|(k, v)| v.as_ref().map(|v| (*k, v.to_owned()))).collect();
 242         OnUnimplementedNote {
 243             label: label.map(|l| l.format(tcx, trait_ref, &options)),
 244             message: message.map(|m| m.format(tcx, trait_ref, &options)),
 245             note: note.map(|n| n.format(tcx, trait_ref, &options)),
 246             enclosing_scope: enclosing_scope.map(|e_s| e_s.format(tcx, trait_ref, &options)),
 247         }
 248     }
 249 }
 250
 251 impl<'tcx> OnUnimplementedFormatString {
 252     fn try_parse(
 253         tcx: TyCtxt<'tcx>,
 254         trait_def_id: DefId,
 255         from: Symbol,
 256         err_sp: Span,
 257     ) -> Result<Self, ErrorReported> {
 258         let result = OnUnimplementedFormatString(from);
 259         result.verify(tcx, trait_def_id, err_sp)?;
 260         Ok(result)
 261     }
 262
 263     fn verify(
 264         &self,
 265         tcx: TyCtxt<'tcx>,
 266         trait_def_id: DefId,
 267         span: Span,
 268     ) -> Result<(), ErrorReported> {
 269         let name = tcx.item_name(trait_def_id);
 270         let generics = tcx.generics_of(trait_def_id);
 271         let s = self.0.as_str();
 272         let parser = Parser::new(s, None, None, false, ParseMode::Format);
 273         let mut result = Ok(());
 274         for token in parser {
 275             match token {
 276                 Piece::String(_) => (), // Normal string, no need to check it
 277                 Piece::NextArgument(a) => match a.position {
 278                     // `{Self}` is allowed
 279                     Position::ArgumentNamed(s) if s == kw::SelfUpper => (),
 280                     // `{ThisTraitsName}` is allowed
 281                     Position::ArgumentNamed(s) if s == name => (),
 282                     // `{from_method}` is allowed
 283                     Position::ArgumentNamed(s) if s == sym::from_method => (),
 284                     // `{from_desugaring}` is allowed
 285                     Position::ArgumentNamed(s) if s == sym::from_desugaring => (),
 286                     // `{ItemContext}` is allowed
 287                     Position::ArgumentNamed(s) if s == sym::ItemContext => (),
 288                     // So is `{A}` if A is a type parameter
 289                     Position::ArgumentNamed(s) => {
 290                         match generics.params.iter().find(|param| param.name == s) {
 291                             Some(_) => (),
 292                             None => {
 293                                 struct_span_err!(
 294                                     tcx.sess,
 295                                     span,
 296                                     E0230,
 297                                     "there is no parameter `{}` on trait `{}`",
 298                                     s,
 299                                     name
 300                                 )
 301                                 .emit();
 302                                 result = Err(ErrorReported);
 303                             }
 304                         }
 305                     }
 306                     // `{:1}` and `{}` are not to be used
 307                     Position::ArgumentIs(_) | Position::ArgumentImplicitlyIs(_) => {
 308                         struct_span_err!(
 309                             tcx.sess,
 310                             span,
 311                             E0231,
 312                             "only named substitution parameters are allowed"
 313                         )
 314                         .emit();
 315                         result = Err(ErrorReported);
 316                     }
 317                 },
 318             }
 319         }
 320
 321         result
 322     }
 323
 324     pub fn format(
 325         &self,
 326         tcx: TyCtxt<'tcx>,
 327         trait_ref: ty::TraitRef<'tcx>,
 328         options: &FxHashMap<Symbol, String>,
 329     ) -> 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
 334             .params
 335             .iter()
 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()
 340                     }
 341                     GenericParamDefKind::Lifetime => return None,
 342                 };
 343                 let name = param.name;
 344                 Some((name, value))
 345             })
 346             .collect::<FxHashMap<Symbol, String>>();
 347         let empty_string = String::new();
 348
 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);
 352         parser
 353             .map(|p| match p {
 354                 Piece::String(s) => s,
 355                 Piece::NextArgument(a) => match a.position {
 356                     Position::ArgumentNamed(s) => match generic_map.get(&s) {
 357                         Some(val) => val,
 358                         None if s == name => &trait_str,
 359                         None => {
 360                             if let Some(val) = options.get(&s) {
 361                                 val
 362                             } else if s == sym::from_desugaring || s == sym::from_method {
 363                                 // don't break messages using these two arguments incorrectly
 364                                 &empty_string
 365                             } else if s == sym::ItemContext {
 366                                 &item_context
 367                             } else {
 368                                 bug!(
 369                                     "broken on_unimplemented {:?} for {:?}: \
 370                                       no argument matching {:?}",
 371                                     self.0,
 372                                     trait_ref,
 373                                     s
 374                                 )
 375                             }
 376                         }
 377                     },
 378                     _ => bug!("broken on_unimplemented {:?} - bad format arg", self.0),
 379                 },
 380             })
 381             .collect()
 382     }
 383 }