| #![deny(unused_must_use)] |
| use proc_macro::Diagnostic; |
| use quote::{format_ident, quote}; |
| use syn::spanned::Spanned; |
| |
| use std::collections::{BTreeSet, HashMap}; |
| |
| /// Implements #[derive(SessionDiagnostic)], which allows for errors to be specified as a struct, independent |
| /// from the actual diagnostics emitting code. |
| /// ```ignore (pseudo-rust) |
| /// # extern crate rustc_errors; |
| /// # use rustc_errors::Applicability; |
| /// # extern crate rustc_span; |
| /// # use rustc_span::{symbol::Ident, Span}; |
| /// # extern crate rust_middle; |
| /// # use rustc_middle::ty::Ty; |
| /// #[derive(SessionDiagnostic)] |
| /// #[code = "E0505"] |
| /// #[error = "cannot move out of {name} because it is borrowed"] |
| /// pub struct MoveOutOfBorrowError<'tcx> { |
| /// pub name: Ident, |
| /// pub ty: Ty<'tcx>, |
| /// #[label = "cannot move out of borrow"] |
| /// pub span: Span, |
| /// #[label = "`{ty}` first borrowed here"] |
| /// pub other_span: Span, |
| /// #[suggestion(message = "consider cloning here", code = "{name}.clone()")] |
| /// pub opt_sugg: Option<(Span, Applicability)> |
| /// } |
| /// ``` |
| /// Then, later, to emit the error: |
| /// |
| /// ```ignore (pseudo-rust) |
| /// sess.emit_err(MoveOutOfBorrowError { |
| /// expected, |
| /// actual, |
| /// span, |
| /// other_span, |
| /// opt_sugg: Some(suggestion, Applicability::MachineApplicable), |
| /// }); |
| /// ``` |
| pub fn session_diagnostic_derive(s: synstructure::Structure<'_>) -> proc_macro2::TokenStream { |
| // Names for the diagnostic we build and the session we build it from. |
| let diag = format_ident!("diag"); |
| let sess = format_ident!("sess"); |
| |
| SessionDiagnosticDerive::new(diag, sess, s).into_tokens() |
| } |
| |
| // Checks whether the type name of `ty` matches `name`. |
| // |
| // Given some struct at a::b::c::Foo, this will return true for c::Foo, b::c::Foo, or |
| // a::b::c::Foo. This reasonably allows qualified names to be used in the macro. |
| fn type_matches_path(ty: &syn::Type, name: &[&str]) -> bool { |
| if let syn::Type::Path(ty) = ty { |
| ty.path |
| .segments |
| .iter() |
| .map(|s| s.ident.to_string()) |
| .rev() |
| .zip(name.iter().rev()) |
| .all(|(x, y)| &x.as_str() == y) |
| } else { |
| false |
| } |
| } |
| |
| /// The central struct for constructing the as_error method from an annotated struct. |
| struct SessionDiagnosticDerive<'a> { |
| structure: synstructure::Structure<'a>, |
| builder: SessionDiagnosticDeriveBuilder<'a>, |
| } |
| |
| impl std::convert::From<syn::Error> for SessionDiagnosticDeriveError { |
| fn from(e: syn::Error) -> Self { |
| SessionDiagnosticDeriveError::SynError(e) |
| } |
| } |
| |
| /// Equivalent to rustc:errors::diagnostic::DiagnosticId, except stores the quoted expression to |
| /// initialise the code with. |
| enum DiagnosticId { |
| Error(proc_macro2::TokenStream), |
| Lint(proc_macro2::TokenStream), |
| } |
| |
| #[derive(Debug)] |
| enum SessionDiagnosticDeriveError { |
| SynError(syn::Error), |
| ErrorHandled, |
| } |
| |
| impl SessionDiagnosticDeriveError { |
| fn to_compile_error(self) -> proc_macro2::TokenStream { |
| match self { |
| SessionDiagnosticDeriveError::SynError(e) => e.to_compile_error(), |
| SessionDiagnosticDeriveError::ErrorHandled => { |
| // Return ! to avoid having to create a blank DiagnosticBuilder to return when an |
| // error has already been emitted to the compiler. |
| quote! { |
| unreachable!() |
| } |
| } |
| } |
| } |
| } |
| |
| fn span_err(span: impl proc_macro::MultiSpan, msg: &str) -> proc_macro::Diagnostic { |
| Diagnostic::spanned(span, proc_macro::Level::Error, msg) |
| } |
| |
| /// For methods that return a Result<_, SessionDiagnosticDeriveError>: emit a diagnostic on |
| /// span $span with msg $msg (and, optionally, perform additional decoration using the FnOnce |
| /// passed in `diag`). Then, return Err(ErrorHandled). |
| macro_rules! throw_span_err { |
| ($span:expr, $msg:expr) => {{ throw_span_err!($span, $msg, |diag| diag) }}; |
| ($span:expr, $msg:expr, $f:expr) => {{ |
| return Err(_throw_span_err($span, $msg, $f)); |
| }}; |
| } |
| |
| /// When possible, prefer using throw_span_err! over using this function directly. This only exists |
| /// as a function to constrain `f` to an impl FnOnce. |
| fn _throw_span_err( |
| span: impl proc_macro::MultiSpan, |
| msg: &str, |
| f: impl FnOnce(proc_macro::Diagnostic) -> proc_macro::Diagnostic, |
| ) -> SessionDiagnosticDeriveError { |
| let diag = span_err(span, msg); |
| f(diag).emit(); |
| SessionDiagnosticDeriveError::ErrorHandled |
| } |
| |
| impl<'a> SessionDiagnosticDerive<'a> { |
| fn new(diag: syn::Ident, sess: syn::Ident, structure: synstructure::Structure<'a>) -> Self { |
| // Build the mapping of field names to fields. This allows attributes to peek values from |
| // other fields. |
| let mut fields_map = HashMap::new(); |
| |
| // Convenience bindings. |
| let ast = structure.ast(); |
| |
| if let syn::Data::Struct(syn::DataStruct { fields, .. }) = &ast.data { |
| for field in fields.iter() { |
| if let Some(ident) = &field.ident { |
| fields_map.insert(ident.to_string(), field); |
| } |
| } |
| } |
| |
| Self { |
| builder: SessionDiagnosticDeriveBuilder { diag, sess, fields: fields_map, kind: None }, |
| structure, |
| } |
| } |
| fn into_tokens(self) -> proc_macro2::TokenStream { |
| let SessionDiagnosticDerive { structure, mut builder } = self; |
| |
| let ast = structure.ast(); |
| let attrs = &ast.attrs; |
| |
| let implementation = { |
| if let syn::Data::Struct(..) = ast.data { |
| let preamble = { |
| let preamble = attrs.iter().map(|attr| { |
| builder |
| .generate_structure_code(attr) |
| .unwrap_or_else(|v| v.to_compile_error()) |
| }); |
| quote! { |
| #(#preamble)*; |
| } |
| }; |
| |
| let body = structure.each(|field_binding| { |
| let field = field_binding.ast(); |
| let result = field.attrs.iter().map(|attr| { |
| builder |
| .generate_field_code( |
| attr, |
| FieldInfo { |
| vis: &field.vis, |
| binding: field_binding, |
| ty: &field.ty, |
| span: &field.span(), |
| }, |
| ) |
| .unwrap_or_else(|v| v.to_compile_error()) |
| }); |
| return quote! { |
| #(#result);* |
| }; |
| }); |
| // Finally, putting it altogether. |
| match builder.kind { |
| None => { |
| span_err(ast.span().unwrap(), "`code` not specified") |
| .help("use the [code = \"...\"] attribute to set this diagnostic's error code ") |
| .emit(); |
| SessionDiagnosticDeriveError::ErrorHandled.to_compile_error() |
| } |
| Some((kind, _)) => match kind { |
| DiagnosticId::Lint(_lint) => todo!(), |
| DiagnosticId::Error(code) => { |
| let (diag, sess) = (&builder.diag, &builder.sess); |
| quote! { |
| let mut #diag = #sess.struct_err_with_code("", rustc_errors::DiagnosticId::Error(#code)); |
| #preamble |
| match self { |
| #body |
| } |
| #diag |
| } |
| } |
| }, |
| } |
| } else { |
| span_err( |
| ast.span().unwrap(), |
| "`#[derive(SessionDiagnostic)]` can only be used on structs", |
| ) |
| .emit(); |
| SessionDiagnosticDeriveError::ErrorHandled.to_compile_error() |
| } |
| }; |
| |
| let sess = &builder.sess; |
| structure.gen_impl(quote! { |
| gen impl<'__session_diagnostic_sess> rustc_session::SessionDiagnostic<'__session_diagnostic_sess> |
| for @Self |
| { |
| fn into_diagnostic( |
| self, |
| #sess: &'__session_diagnostic_sess rustc_session::Session |
| ) -> rustc_errors::DiagnosticBuilder<'__session_diagnostic_sess> { |
| #implementation |
| } |
| } |
| }) |
| } |
| } |
| |
| /// Field information passed to the builder. Deliberately omits attrs to discourage the generate_* |
| /// methods from walking the attributes themselves. |
| struct FieldInfo<'a> { |
| vis: &'a syn::Visibility, |
| binding: &'a synstructure::BindingInfo<'a>, |
| ty: &'a syn::Type, |
| span: &'a proc_macro2::Span, |
| } |
| |
| /// Tracks persistent information required for building up the individual calls to diagnostic |
| /// methods for the final generated method. This is a separate struct to SessionDerive only to be |
| /// able to destructure and split self.builder and the self.structure up to avoid a double mut |
| /// borrow later on. |
| struct SessionDiagnosticDeriveBuilder<'a> { |
| /// Name of the session parameter that's passed in to the as_error method. |
| sess: syn::Ident, |
| |
| /// Store a map of field name to its corresponding field. This is built on construction of the |
| /// derive builder. |
| fields: HashMap<String, &'a syn::Field>, |
| |
| /// The identifier to use for the generated DiagnosticBuilder instance. |
| diag: syn::Ident, |
| |
| /// Whether this is a lint or an error. This dictates how the diag will be initialised. Span |
| /// stores at what Span the kind was first set at (for error reporting purposes, if the kind |
| /// was multiply specified). |
| kind: Option<(DiagnosticId, proc_macro2::Span)>, |
| } |
| |
| impl<'a> SessionDiagnosticDeriveBuilder<'a> { |
| fn generate_structure_code( |
| &mut self, |
| attr: &syn::Attribute, |
| ) -> Result<proc_macro2::TokenStream, SessionDiagnosticDeriveError> { |
| Ok(match attr.parse_meta()? { |
| syn::Meta::NameValue(syn::MetaNameValue { lit: syn::Lit::Str(s), .. }) => { |
| let formatted_str = self.build_format(&s.value(), attr.span()); |
| let name = attr.path.segments.last().unwrap().ident.to_string(); |
| let name = name.as_str(); |
| match name { |
| "message" => { |
| let diag = &self.diag; |
| quote! { |
| #diag.set_primary_message(#formatted_str); |
| } |
| } |
| attr @ "error" | attr @ "lint" => { |
| self.set_kind_once( |
| if attr == "error" { |
| DiagnosticId::Error(formatted_str) |
| } else if attr == "lint" { |
| DiagnosticId::Lint(formatted_str) |
| } else { |
| unreachable!() |
| }, |
| s.span(), |
| )?; |
| // This attribute is only allowed to be applied once, and the attribute |
| // will be set in the initialisation code. |
| quote! {} |
| } |
| other => throw_span_err!( |
| attr.span().unwrap(), |
| &format!( |
| "`#[{} = ...]` is not a valid SessionDiagnostic struct attribute", |
| other |
| ) |
| ), |
| } |
| } |
| _ => todo!("unhandled meta kind"), |
| }) |
| } |
| |
| #[must_use] |
| fn set_kind_once( |
| &mut self, |
| kind: DiagnosticId, |
| span: proc_macro2::Span, |
| ) -> Result<(), SessionDiagnosticDeriveError> { |
| if self.kind.is_none() { |
| self.kind = Some((kind, span)); |
| Ok(()) |
| } else { |
| let kind_str = |kind: &DiagnosticId| match kind { |
| DiagnosticId::Lint(..) => "lint", |
| DiagnosticId::Error(..) => "error", |
| }; |
| |
| let existing_kind = kind_str(&self.kind.as_ref().unwrap().0); |
| let this_kind = kind_str(&kind); |
| |
| let msg = if this_kind == existing_kind { |
| format!("`{}` specified multiple times", existing_kind) |
| } else { |
| format!("`{}` specified when `{}` was already specified", this_kind, existing_kind) |
| }; |
| throw_span_err!(span.unwrap(), &msg); |
| } |
| } |
| |
| fn generate_field_code( |
| &mut self, |
| attr: &syn::Attribute, |
| info: FieldInfo<'_>, |
| ) -> Result<proc_macro2::TokenStream, SessionDiagnosticDeriveError> { |
| let field_binding = &info.binding.binding; |
| |
| let option_ty = option_inner_ty(info.ty); |
| |
| let generated_code = self.generate_non_option_field_code( |
| attr, |
| FieldInfo { |
| vis: info.vis, |
| binding: info.binding, |
| ty: option_ty.unwrap_or(info.ty), |
| span: info.span, |
| }, |
| )?; |
| Ok(if option_ty.is_none() { |
| quote! { #generated_code } |
| } else { |
| quote! { |
| if let Some(#field_binding) = #field_binding { |
| #generated_code |
| } |
| } |
| }) |
| } |
| |
| fn generate_non_option_field_code( |
| &mut self, |
| attr: &syn::Attribute, |
| info: FieldInfo<'_>, |
| ) -> Result<proc_macro2::TokenStream, SessionDiagnosticDeriveError> { |
| let diag = &self.diag; |
| let field_binding = &info.binding.binding; |
| let name = attr.path.segments.last().unwrap().ident.to_string(); |
| let name = name.as_str(); |
| // At this point, we need to dispatch based on the attribute key + the |
| // type. |
| let meta = attr.parse_meta()?; |
| Ok(match meta { |
| syn::Meta::NameValue(syn::MetaNameValue { lit: syn::Lit::Str(s), .. }) => { |
| let formatted_str = self.build_format(&s.value(), attr.span()); |
| match name { |
| "message" => { |
| if type_matches_path(info.ty, &["rustc_span", "Span"]) { |
| quote! { |
| #diag.set_span(*#field_binding); |
| #diag.set_primary_message(#formatted_str); |
| } |
| } else { |
| throw_span_err!( |
| attr.span().unwrap(), |
| "the `#[message = \"...\"]` attribute can only be applied to fields of type Span" |
| ); |
| } |
| } |
| "label" => { |
| if type_matches_path(info.ty, &["rustc_span", "Span"]) { |
| quote! { |
| #diag.span_label(*#field_binding, #formatted_str); |
| } |
| } else { |
| throw_span_err!( |
| attr.span().unwrap(), |
| "The `#[label = ...]` attribute can only be applied to fields of type Span" |
| ); |
| } |
| } |
| other => throw_span_err!( |
| attr.span().unwrap(), |
| &format!( |
| "`#[{} = ...]` is not a valid SessionDiagnostic field attribute", |
| other |
| ) |
| ), |
| } |
| } |
| syn::Meta::List(list) => { |
| match list.path.segments.iter().last().unwrap().ident.to_string().as_str() { |
| suggestion_kind @ "suggestion" |
| | suggestion_kind @ "suggestion_short" |
| | suggestion_kind @ "suggestion_hidden" |
| | suggestion_kind @ "suggestion_verbose" => { |
| // For suggest, we need to ensure we are running on a (Span, |
| // Applicability) pair. |
| let (span, applicability) = (|| match &info.ty { |
| ty @ syn::Type::Path(..) |
| if type_matches_path(ty, &["rustc_span", "Span"]) => |
| { |
| let binding = &info.binding.binding; |
| Ok(( |
| quote!(*#binding), |
| quote!(rustc_errors::Applicability::Unspecified), |
| )) |
| } |
| syn::Type::Tuple(tup) => { |
| let mut span_idx = None; |
| let mut applicability_idx = None; |
| for (idx, elem) in tup.elems.iter().enumerate() { |
| if type_matches_path(elem, &["rustc_span", "Span"]) { |
| if span_idx.is_none() { |
| span_idx = Some(syn::Index::from(idx)); |
| } else { |
| throw_span_err!( |
| info.span.unwrap(), |
| "type of field annotated with `#[suggestion(...)]` contains more than one Span" |
| ); |
| } |
| } else if type_matches_path( |
| elem, |
| &["rustc_errors", "Applicability"], |
| ) { |
| if applicability_idx.is_none() { |
| applicability_idx = Some(syn::Index::from(idx)); |
| } else { |
| throw_span_err!( |
| info.span.unwrap(), |
| "type of field annotated with `#[suggestion(...)]` contains more than one Applicability" |
| ); |
| } |
| } |
| } |
| if let Some(span_idx) = span_idx { |
| let binding = &info.binding.binding; |
| let span = quote!(#binding.#span_idx); |
| let applicability = applicability_idx |
| .map( |
| |applicability_idx| quote!(#binding.#applicability_idx), |
| ) |
| .unwrap_or_else(|| { |
| quote!(rustc_errors::Applicability::Unspecified) |
| }); |
| return Ok((span, applicability)); |
| } |
| throw_span_err!( |
| info.span.unwrap(), |
| "wrong types for suggestion", |
| |diag| { |
| diag.help("#[suggestion(...)] on a tuple field must be applied to fields of type (Span, Applicability)") |
| } |
| ); |
| } |
| _ => throw_span_err!( |
| info.span.unwrap(), |
| "wrong field type for suggestion", |
| |diag| { |
| diag.help("#[suggestion(...)] should be applied to fields of type Span or (Span, Applicability)") |
| } |
| ), |
| })()?; |
| // Now read the key-value pairs. |
| let mut msg = None; |
| let mut code = None; |
| |
| for arg in list.nested.iter() { |
| if let syn::NestedMeta::Meta(syn::Meta::NameValue(arg_name_value)) = arg |
| { |
| if let syn::MetaNameValue { lit: syn::Lit::Str(s), .. } = |
| arg_name_value |
| { |
| let name = arg_name_value |
| .path |
| .segments |
| .last() |
| .unwrap() |
| .ident |
| .to_string(); |
| let name = name.as_str(); |
| let formatted_str = self.build_format(&s.value(), arg.span()); |
| match name { |
| "message" => { |
| msg = Some(formatted_str); |
| } |
| "code" => { |
| code = Some(formatted_str); |
| } |
| other => throw_span_err!( |
| arg.span().unwrap(), |
| &format!( |
| "`{}` is not a valid key for `#[suggestion(...)]`", |
| other |
| ) |
| ), |
| } |
| } |
| } |
| } |
| let msg = if let Some(msg) = msg { |
| quote!(#msg.as_str()) |
| } else { |
| throw_span_err!( |
| list.span().unwrap(), |
| "missing suggestion message", |
| |diag| { |
| diag.help("provide a suggestion message using #[suggestion(message = \"...\")]") |
| } |
| ); |
| }; |
| let code = code.unwrap_or_else(|| quote! { String::new() }); |
| // Now build it out: |
| let suggestion_method = format_ident!("span_{}", suggestion_kind); |
| quote! { |
| #diag.#suggestion_method(#span, #msg, #code, #applicability); |
| } |
| } |
| other => throw_span_err!( |
| list.span().unwrap(), |
| &format!("invalid annotation list `#[{}(...)]`", other) |
| ), |
| } |
| } |
| _ => panic!("unhandled meta kind"), |
| }) |
| } |
| |
| /// In the strings in the attributes supplied to this macro, we want callers to be able to |
| /// reference fields in the format string. Take this, for example: |
| /// ```ignore (not-usage-example) |
| /// struct Point { |
| /// #[error = "Expected a point greater than ({x}, {y})"] |
| /// x: i32, |
| /// y: i32, |
| /// } |
| /// ``` |
| /// We want to automatically pick up that {x} refers `self.x` and {y} refers to `self.y`, then |
| /// generate this call to format!: |
| /// ```ignore (not-usage-example) |
| /// format!("Expected a point greater than ({x}, {y})", x = self.x, y = self.y) |
| /// ``` |
| /// This function builds the entire call to format!. |
| fn build_format(&self, input: &str, span: proc_macro2::Span) -> proc_macro2::TokenStream { |
| // This set is used later to generate the final format string. To keep builds reproducible, |
| // the iteration order needs to be deterministic, hence why we use a BTreeSet here instead |
| // of a HashSet. |
| let mut referenced_fields: BTreeSet<String> = BTreeSet::new(); |
| |
| // At this point, we can start parsing the format string. |
| let mut it = input.chars().peekable(); |
| // Once the start of a format string has been found, process the format string and spit out |
| // the referenced fields. Leaves `it` sitting on the closing brace of the format string, so the |
| // next call to `it.next()` retrieves the next character. |
| while let Some(c) = it.next() { |
| if c == '{' && *it.peek().unwrap_or(&'\0') != '{' { |
| #[must_use] |
| let mut eat_argument = || -> Option<String> { |
| let mut result = String::new(); |
| // Format specifiers look like |
| // format := '{' [ argument ] [ ':' format_spec ] '}' . |
| // Therefore, we only need to eat until ':' or '}' to find the argument. |
| while let Some(c) = it.next() { |
| result.push(c); |
| let next = *it.peek().unwrap_or(&'\0'); |
| if next == '}' { |
| break; |
| } else if next == ':' { |
| // Eat the ':' character. |
| assert_eq!(it.next().unwrap(), ':'); |
| break; |
| } |
| } |
| // Eat until (and including) the matching '}' |
| while it.next()? != '}' { |
| continue; |
| } |
| Some(result) |
| }; |
| |
| if let Some(referenced_field) = eat_argument() { |
| referenced_fields.insert(referenced_field); |
| } |
| } |
| } |
| // At this point, `referenced_fields` contains a set of the unique fields that were |
| // referenced in the format string. Generate the corresponding "x = self.x" format |
| // string parameters: |
| let args = referenced_fields.into_iter().map(|field: String| { |
| let field_ident = format_ident!("{}", field); |
| let value = if self.fields.contains_key(&field) { |
| quote! { |
| &self.#field_ident |
| } |
| } else { |
| // This field doesn't exist. Emit a diagnostic. |
| Diagnostic::spanned( |
| span.unwrap(), |
| proc_macro::Level::Error, |
| format!("`{}` doesn't refer to a field on this type", field), |
| ) |
| .emit(); |
| quote! { |
| "{#field}" |
| } |
| }; |
| quote! { |
| #field_ident = #value |
| } |
| }); |
| quote! { |
| format!(#input #(,#args)*) |
| } |
| } |
| } |
| |
| /// If `ty` is an Option, returns Some(inner type). Else, returns None. |
| fn option_inner_ty(ty: &syn::Type) -> Option<&syn::Type> { |
| if type_matches_path(ty, &["std", "option", "Option"]) { |
| if let syn::Type::Path(ty_path) = ty { |
| let path = &ty_path.path; |
| let ty = path.segments.iter().last().unwrap(); |
| if let syn::PathArguments::AngleBracketed(bracketed) = &ty.arguments { |
| if bracketed.args.len() == 1 { |
| if let syn::GenericArgument::Type(ty) = &bracketed.args[0] { |
| return Some(ty); |
| } |
| } |
| } |
| } |
| } |
| None |
| } |
