Add derive macro for specifying diagnostics using attributes. #75138

jumbatm · 2020-08-04T09:35:06Z

Introduces #[derive(SessionDiagnostic)], a derive macro for specifying structs that can be converted to Diagnostics using directions given by attributes on the struct and its fields. Currently, the following attributes have been implemented:

#[code = "..."] -- this sets the Diagnostic's error code, and must be provided on the struct iself (ie, not on a field). Equivalent to calling code.
#[message = "..."] -- this sets the Diagnostic's primary error message.
#[label = "..."] -- this must be applied to fields of type Span, and is equivalent to span_label
#[suggestion(..)] -- this allows a suggestion message to be supplied. This attribute must be applied to a field of type Span or (Span, Applicability), and is equivalent to calling span_suggestion. Valid arguments are:
- message = "..." -- this sets the suggestion message.
- (Optional) code = "..." -- this suggests code for the suggestion. Defaults to empty.

suggestionalso comes with other variants: #[suggestion_short(..)], #[suggestion_hidden(..)] and #[suggestion_verbose(..)] which all take the same keys.

Within the strings passed to each attribute, fields can be referenced without needing to be passed explicitly into the format string -- eg, #[error = "{ident} already declared"] will set the error message to format!("{} already declared", &self.ident). Any fields on the struct can be referenced in this way.

Additionally, for any of these attributes, Option fields can be used to only optionally apply the decoration -- for example:

#[derive(SessionDiagnostic)]
#[code = "E0123"]
struct SomeKindOfError {
    ...
    #[suggestion(message = "informative error message")]
    opt_sugg: Option<(Span, Applicability)>
    ...
}

will not emit a suggestion if opt_sugg is None.

We plan on iterating on this macro further; this PR is a start.

Closes #61132.

r? @oli-obk

jumbatm · 2020-08-04T10:01:42Z

src/librustc_typeck/collect.rs

-                struct_span_err!(
-                    tcx.sess,
-                    f.span,
-                    E0124,
-                    "field `{}` is already declared",
-                    f.ident
-                )
-                .span_label(f.span, "field already declared")
-                .span_label(prev_span, format!("`{}` first declared here", f.ident))
-                .emit();
+                #[derive(SessionDiagnostic)]
+                #[code = "E0124"]
+                struct FieldAlreadyDeclared {
+                    field_name: String,
+                    #[error = "field `{field_name}` is already declared"]
+                    #[label = "field already declared"]
+                    span: Span,
+                    #[label = "`{field_name}` first declared here"]
+                    prev_span: Span,
+                }
+
+                tcx.sess.emit_err(FieldAlreadyDeclared {
+                    field_name: f.ident.to_string(),
+                    span: f.span,
+                    prev_span,
+                });


Here's an existing diagnostic I've replaced, which demonstrates an actual usage of the derive macro.

oli-obk

cc @rust-lang/wg-diagnostics have a look at this epic PR

@jumbatm I'm a bit unsure about the "type checks" in general. I have commented where I think they can be removed in favour of other schemes, but e.g. the Option example is a bit more complex. We may be able to work around this by creating a MaybeOption trait that just doesn't do anything for None:

trait MaybeOption<T> {
    fn maybe_do(self, f: impl FnOnce(T));
}

impl<T> MaybeOption<T> for T {
    fn maybe_do(self, f: impl FnOnce(T)){
        f(self)
    }
}

impl<T> MaybeOption<T> for Option<T> {
    fn maybe_do(self, f: impl FnOnce(T)) {
        if let Some(this) = self {
            f(this)
        }
    }
}

src/librustc_typeck/collect.rs