Serialization of errors using MietteDiagnostic?

[lquerel]

Hi @zkat. All my errors are annotated with #[derive(Diagnostic)] and 'serde' is enabled at the crate level of miette. I can easily create a report from this type of error via into(). However, I have not found how to obtain a serializable MietteDiagnostic from this report or directly from the error. Thanks in advance. This crate is fantastic!

[zkat]

You have two choices: MietteDiagnostic supports serde Serialize, or you can use the JSONReportHandler to output any Diagnostic to JSON.

[lquerel]

Let me clarify my need more clearly. I need a way to pass an enum annotated with #[derive(Diagnostic)] to an external function that takes as a parameter something implementing the Serialize trait. The option of using the JSONReportHandler is therefore not an option for me. What I actually want to pass to this function is an instance of MietteDiagnostic derived from my enum or from a miette report. However, I have not found how to perform this conversion, other than by manually reconstructing an entire instance of MietteDiagnostic.

Here's an example to make things more concrete.

#[test]
fn test_ser() {
    fn external_function<T: Serialize>(arg: T) {
        // Do something with the argument.
    }

    #[derive(Error, Diagnostic, Debug)]
    enum Error {
        #[diagnostic(
            code(ast::id),
            severity(Error),
            url(docsrs),
            help("Only dots and underscores are allowed in IDs.")
        )]
        #[error("Invalid ID syntax.")]
        InvalidIdSyntax {
            #[source_code]
            src: NamedSource<String>,
            #[label("This ID here")]
            invalid_id: SourceSpan,
        }
    }

    let src = "x = 10\ny-1=12\nprint(x)".to_owned();
    let error = Error::InvalidIdSyntax {
        src: NamedSource::new("file.xyz", src.clone()),
        invalid_id: (7, 3).into(),
    };

    // This works, but it's not exactly what I need because I require
    // an object implementing Serialize for my specific use case.
    let report_handler = JSONReportHandler::new();
    let mut json = String::new();
    report_handler.render_report(&mut json, &error).unwrap();
    println!("{}", json);

    // The error is not serializable, so the following code will not compile.
    // external_function(error);

    let report: Report = error.into();
    // The report is not serializable, so the following code will not compile.
    // external_function(report);
    
    // This works because the MietteDiagnostic is serializable.
    // But how can I construct a MietteDiagnostic from my enum or from a Report?
    external_function(MietteDiagnostic::new("bla"));
}