Struct Diagnostic 

pub struct Diagnostic { /* private fields */ }

One message a stage reports about the program under compilation.

A diagnostic pairs a Severity with a human-readable message. Stages create diagnostics and hand them to the Session, which stores them in emission order and keeps a running count of how many were errors. The driver owns policy — whether to keep going after an error, when to stop — while the diagnostic is just the record of what happened.

The message is a Cow<'static, str>: a fixed message ("unexpected end of input") is stored as a borrowed &'static str with no allocation, while a computed one (format!("unknown name {name}")) is owned only when it is actually built. This keeps the common “constant message” path allocation-free.

This type is deliberately small — a severity and a message, nothing else. driver-lang does not model spans, error codes, or suggestions: those belong to a dedicated diagnostics crate that a language can plug in as its own concern. The driver only needs enough to route messages and decide when to abort.

Examples

use driver_lang::{Diagnostic, Severity};

let d = Diagnostic::error("unexpected `}`");
assert_eq!(d.severity(), Severity::Error);
assert_eq!(d.message(), "unexpected `}`");
assert!(d.is_error());

Implementations

impl Diagnostic

pub fn new(severity: Severity, message: impl Into<Cow<'static, str>>) -> Self

Create a diagnostic with an explicit Severity.

The message accepts a string literal (stored without allocation) or an owned String (a computed message). Prefer the error, warning, and note shorthands when the severity is known at the call site.

Examples

use driver_lang::{Diagnostic, Severity};

let from_literal = Diagnostic::new(Severity::Note, "defined here");
let from_owned = Diagnostic::new(Severity::Note, String::from("defined here"));
assert_eq!(from_literal, from_owned);

pub fn error(message: impl Into<Cow<'static, str>>) -> Self

Create an Error diagnostic — a hard failure that counts toward the session’s error total.

Examples

use driver_lang::Diagnostic;

let d = Diagnostic::error("type mismatch");
assert!(d.is_error());

pub fn warning(message: impl Into<Cow<'static, str>>) -> Self

Create a Warning diagnostic — recorded and shown, but it does not by itself stop the build.

Examples

use driver_lang::Diagnostic;

let d = Diagnostic::warning("unused variable `x`");
assert!(!d.is_error());

pub fn note(message: impl Into<Cow<'static, str>>) -> Self

Create a Note diagnostic — neutral context attached to the output.

Examples

use driver_lang::Diagnostic;

let d = Diagnostic::note("`main` is defined here");
assert!(!d.is_error());

pub fn severity(&self) -> Severity

The Severity of this diagnostic.

pub fn message(&self) -> &str

The message text.

Examples

use driver_lang::Diagnostic;

assert_eq!(Diagnostic::error("boom").message(), "boom");

pub fn is_error(&self) -> bool

Whether this diagnostic’s severity is Error.

A shorthand for self.severity().is_error(), the same test the Session uses to decide whether a diagnostic counts toward its error total.

Examples

use driver_lang::Diagnostic;

assert!(Diagnostic::error("boom").is_error());
assert!(!Diagnostic::warning("hmm").is_error());

Trait Implementations

impl Clone for Diagnostic

fn clone(&self) -> Diagnostic

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Diagnostic

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Diagnostic

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Renders as severity: message, e.g. error: unexpected }``.

impl Eq for Diagnostic

impl PartialEq for Diagnostic

fn eq(&self, other: &Diagnostic) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Diagnostic

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Diagnostic