A dynamic #[related] diagnostics container

[CAD97]

This might be interesting to other people as well, as a way to collect diagnostics during e.g. compilation.

This can obviously be improved in a few ways. However, this isn't really meant to be used as-is; it's meant to be basically a "pattern" you use and adapt for your system's specific requirements.

Dynamic Diagnostic box which impl Diagnostic

#[derive(Debug)]
struct DynDiagnostic {
    inner: Box<dyn Diagnostic + Send + Sync + 'static>,
}

impl Display for DynDiagnostic {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.inner.fmt(f)
    }
}

impl Error for DynDiagnostic {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        self.inner.source()
    }
}

impl Diagnostic for DynDiagnostic {
    fn code<'a>(&'a self) -> Option<Box<dyn Display + 'a>> {
        self.inner.code()
    }

    fn severity(&self) -> Option<miette::Severity> {
        self.inner.severity()
    }

    fn help<'a>(&'a self) -> Option<Box<dyn Display + 'a>> {
        self.inner.help()
    }

    fn url<'a>(&'a self) -> Option<Box<dyn Display + 'a>> {
        self.inner.url()
    }

    fn source_code(&self) -> Option<&dyn miette::SourceCode> {
        self.inner.source_code()
    }

    fn labels(&self) -> Option<Box<dyn Iterator<Item = miette::LabeledSpan> + '_>> {
        self.inner.labels()
    }

    fn related<'a>(&'a self) -> Option<Box<dyn Iterator<Item = &'a dyn Diagnostic> + 'a>> {
        self.inner.related()
    }
}

impl DynDiagnostic {
    fn new(diagnostic: impl Diagnostic + Send + Sync + 'static) -> Self {
        DynDiagnostic {
            inner: diagnostic.into(),
        }
    }
}

Diagnostic container

#[derive(Debug, Error)]
struct Diagnostics {
    src: String,
    diagnostics: Vec<DynDiagnostic>,
}

impl Diagnostics {
    pub fn new(src: impl Into<String>) -> Self {
        Diagnostics {
            src: src.into(),
            diagnostics: vec![],
        }
    }

    pub fn severity(&self) -> Option<Severity> {
        if self.diagnostics.is_empty() {
            return None;
        }

        let mut severity = Severity::Advice;

        for diagnostic in &self.diagnostics {
            severity = match (severity, diagnostic.severity()) {
                (severity, None) => severity,
                (Severity::Advice, Some(severity)) => severity,
                (Severity::Warning, Some(Severity::Advice)) => Severity::Warning,
                (Severity::Warning, Some(severity)) => severity,
                (Severity::Error, Some(_)) => break,
            }
        }

        Some(severity)
    }

    pub fn push(&mut self, diagnostic: impl Diagnostic + Send + Sync + 'static) {
        self.diagnostics.push(DynDiagnostic::new(diagnostic))
    }
}

impl Display for Diagnostics {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self.severity() {
            Some(Severity::Error) => f.write_str("some errors occurred..."),
            Some(Severity::Warning) => f.write_str("some warnings occurred..."),
            Some(Severity::Advice) => f.write_str("some advice occurred..."),
            None => f.write_str("no diagnostics"),
        }
    }
}

impl Diagnostic for Diagnostics {
    fn severity(&self) -> Option<Severity> {
        self.severity()
    }

    fn source_code(&self) -> Option<&dyn miette::SourceCode> {
        Some(&self.src)
    }

    fn related<'a>(&'a self) -> Option<Box<dyn Iterator<Item = &'a dyn Diagnostic> + 'a>> {
        Some(Box::new(
            self.diagnostics.iter().map(|d| d as &dyn Diagnostic),
        ))
    }
}

Example

#[derive(Error, Debug, Diagnostic)]
#[diagnostic(code(D0000), severity(error))]
#[error("I won't allow this")]
struct SourceError {
    #[label]
    span: SourceSpan,
}

#[derive(Error, Debug, Diagnostic)]
#[diagnostic(code(D4000), severity(warning))]
#[error("I don't like this")]
struct SourceWarning {
    #[label]
    span: SourceSpan,
}

#[derive(Error, Debug, Diagnostic)]
#[diagnostic(code(D8000), severity(advice))]
#[error("This could be better")]
struct SourceAdvice {
    #[label]
    span: SourceSpan,
}

fn main() -> Result<()> {
    let src = "\
this is an error
this is a warning
this is an advice
";

    let error = SourceError {
        span: (11..16).into(),
    };
    let warning = SourceWarning {
        span: (27..34).into(),
    };
    let advice = SourceAdvice {
        span: (46..52).into(),
    };

    let mut diagnostics = Diagnostics::new(src);
    diagnostics.push(error);
    diagnostics.push(warning);
    diagnostics.push(advice);

    Err(diagnostics)?;
    Ok(())
}

D:\repos\cad97\playground> cargo run
   Compiling playground v0.1.0 (D:\repos\cad97\playground)
    Finished dev [unoptimized + debuginfo] target(s) in 1.17s
     Running `D:\.rust\target\debug\playground.exe`
Error:
  × some errors occurred...

Error: D0000

  × I won't allow this
   ╭─[1:1]
 1 │ this is an error
   ·            ─────
 2 │ this is a warning
   ╰────
Error: D4000

  ⚠ I don't like this
   ╭─[1:1]
 1 │ this is an error
 2 │ this is a warning
   ·           ───────
 3 │ this is an advice
   ╰────
Error: D8000

  ☞ This could be better
   ╭─[2:1]
 2 │ this is a warning
 3 │ this is an advice
   ·            ──────
   ╰────

error: process didn't exit successfully: `D:\.rust\target\debug\playground.exe` (exit code: 1)