Enum Severity 

pub enum Severity {
    Error,
    Warning,
    Note,
}

The seriousness of a Diagnostic.

A driver runs a program through a chain of stages, and each stage reports what it found by emitting diagnostics into the Session. The severity is what tells the driver — and the person reading the output — whether a diagnostic is a hard failure that should stop compilation, a heads-up that something looks wrong, or a neutral remark that adds context.

Only Error counts toward Session::error_count; a warning or a note is recorded and rendered but never trips Session::abort_if_errors. Ordering the variants by seriousness — error first — mirrors that: Error < Warning < Note is not the intent, so the type intentionally does not derive Ord. Compare with is_error instead of relying on a numeric rank.

Variants

Error

A hard failure. Counts toward the session’s error total and makes Session::abort_if_errors stop the build.

Warning

Something suspicious that does not by itself stop compilation.

Note

Neutral context attached to the output — a hint, a location, a reminder.

Implementations

impl Severity

pub fn is_error(self) -> bool

Whether this is Severity::Error — the only severity that counts as a build failure.

Examples

use driver_lang::Severity;

assert!(Severity::Error.is_error());
assert!(!Severity::Warning.is_error());
assert!(!Severity::Note.is_error());

pub fn as_str(self) -> &'static str

The lowercase label used when a diagnostic is rendered ("error", "warning", "note").

Examples

use driver_lang::Severity;

assert_eq!(Severity::Error.as_str(), "error");
assert_eq!(Severity::Warning.as_str(), "warning");
assert_eq!(Severity::Note.as_str(), "note");

Trait Implementations

impl Clone for Severity

fn clone(&self) -> Severity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Severity

impl Debug for Severity

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

Formats the value using the given formatter.

impl Display for Severity

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

Formats the value using the given formatter.

impl Eq for Severity

impl Hash for Severity

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Severity

fn eq(&self, other: &Severity) -> 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 Severity

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 Severity