Struct Diagnostic 

pub struct Diagnostic {
    pub severity: Severity,
    pub code: Option<Code>,
    pub message: String,
    pub file: Option<Atom>,
    pub path: Path,
    pub on_key: bool,
    pub line: Option<u32>,
    pub col: Option<u32>,
    pub end_line: Option<u32>,
    pub end_col: Option<u32>,
    pub tool: Option<Atom>,
}

One thing found.

Fields

severity: Severity

How bad it is.

code: Option<Code>

What it is: one of this crate’s Problems (SD0001) or a tool’s own code (E0308, a lint’s name); none until it’s known.

message: String

What’s wrong, for a person.

file: Option<Atom>

The file it’s in.

path: Path

The value it’s about, in its document (entries[2].icon).

on_key: bool

About the key at path rather than its value (an unknown field).

line: Option<u32>

1-based.

col: Option<u32>

Its 1-based column, when known.

end_line: Option<u32>

The line it ends on, when known.

end_col: Option<u32>

The column it ends at, when known.

tool: Option<Atom>

Who found it, when not the tool itself (rustc, cargo).

Implementations

impl Diagnostic

pub fn error(code: impl Into<Code>, message: impl Display) -> Diagnostic

An error of kind code.

pub fn warning(code: impl Into<Code>, message: impl Display) -> Diagnostic

A warning of kind code.

pub fn of( severity: Severity, code: impl Into<Code>, message: impl Display, ) -> Diagnostic

A diagnostic of severity, code and message, not yet placed.

pub fn syntax(e: SyntaxError) -> Diagnostic

Text that doesn’t parse, where it stops.

pub fn in_file(self, file: impl Display) -> Diagnostic

In file.

pub fn at_line(self, line: usize) -> Diagnostic

At line of its file.

pub fn at(self, at: LineCol) -> Diagnostic

At at (a line and column) of its file.

pub fn at_path(self, path: Path) -> Diagnostic

About the value at path.

pub fn by(self, tool: Atom) -> Diagnostic

Found by tool.

pub fn or_code(self, code: impl Into<Code>) -> Diagnostic

Of kind code when its kind isn’t known yet (it was met as plain text).

pub fn map(self, wrap: impl FnOnce(String) -> String) -> Diagnostic

Its message wrapped (<Slot> {e}), the rest kept.

pub fn is_error(&self) -> bool

Whether it’s an 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<(), Error>

Formats the value using the given formatter.

impl Default for Diagnostic

fn default() -> Diagnostic

Returns the “default value” for a type.

impl Display for Diagnostic

As text: file:line:col: path: message, each part when it’s known.

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

Formats the value using the given formatter.

impl Eq for Diagnostic

impl Error for Diagnostic

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl Fields for Diagnostic

const FIELDS: &'static [(&'static str, &'static str)]

Each field’s Rust name and the key it’s written as.

impl From<&str> for Diagnostic

fn from(message: &str) -> Diagnostic

Converts to this type from the input type.

impl From<String> for Diagnostic

An error met as plain text: its kind not known yet (Diagnostic::or_code).

fn from(message: String) -> Diagnostic

Converts to this type from the input type.

impl PartialEq for Diagnostic

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

Equality operator ==.

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

Inequality operator !=.

impl Schema for Diagnostic

fn encode(&self, __sd_w: &mut Writer)

Writes itself in the binary form, straight — Schema::write’s value encoded, unless the type knows better (derived ones do).

fn decode(__sd_d: &mut Decoder<'_>) -> Option<Diagnostic>

Reads itself from the binary form, straight; None when it isn’t what Schema::encode writes — then read_bytes reads the slow way, which says what’s wrong. Through a value unless the type knows better (derived ones do).

fn pack(&self, __sd_p: &mut Packer)

Packs itself into a frame (crate::frame): its binary form as bytes, unless the type packs itself (derived ones and plain types do).

fn unpack(__sd_u: &mut Unpacker<'_>) -> Option<Diagnostic>

Reads itself out of a frame; None if the bytes aren’t what Schema::pack writes.

fn shape() -> Shape

What the format looks like.

fn read(v: &ValueRef<'_>, cx: &mut Reader<'_>) -> Option<Diagnostic>

Reads v. Problems go to cx at its current path; None when the value couldn’t be read (the problem is in cx).

fn write(&self) -> Value

The value, as the format writes it.

fn absent() -> Option<Self>

The value of a field that isn’t there — None: the field is required.

fn skip(&self) -> bool

Whether a struct leaves this field out when writing it.

fn pack_list(items: &[Self], p: &mut Packer)

A list of these packed: a count, then each one (floats raw).

fn unpack_list(u: &mut Unpacker<'_>) -> Option<Vec<Self>>

A list of these out of a frame.

fn encode_list(items: &[Self], w: &mut Writer)

A list of these written straight (numbers pack theirs).

fn decode_list(d: &mut Decoder<'_>) -> Option<Vec<Self>>

A list of these read straight.

impl StructuralPartialEq for Diagnostic