Struct Diagnostic

pub struct Diagnostic {
    pub level: Level,
    pub message: Vec<Message>,
    pub code: Option<DiagnosticId>,
    pub span: MultiSpan,
    pub children: Vec<SubDiagnostic>,
    pub suggestions: Vec<CodeSuggestion>,
}

Fields

level: Level

message: Vec<Message>

code: Option<DiagnosticId>

span: MultiSpan

children: Vec<SubDiagnostic>

suggestions: Vec<CodeSuggestion>

Implementations

impl Diagnostic

pub fn new(level: Level, message: &str) -> Self

pub fn new_with_code( level: Level, code: Option<DiagnosticId>, message: &str, ) -> Self

pub fn is_error(&self) -> bool

pub fn cancel(&mut self)

Cancel the diagnostic (a structured diagnostic must either be emitted or canceled or it will panic when dropped).

pub fn cancelled(&self) -> bool

pub fn span_label<T: Into<String>>(&mut self, span: Span, label: T) -> &mut Self

Add a span/label to be included in the resulting snippet. This is pushed onto the MultiSpan that was created when the diagnostic was first built. If you don’t call this function at all, and you just supplied a Span to create the diagnostic, then the snippet will just include that Span, which is called the primary span.

pub fn replace_span_with(&mut self, after: Span) -> &mut Self

pub fn note_expected_found( &mut self, label: &dyn Display, expected: DiagnosticStyledString, found: DiagnosticStyledString, ) -> &mut Self

pub fn note_expected_found_extra( &mut self, label: &dyn Display, expected: DiagnosticStyledString, found: DiagnosticStyledString, expected_extra: &dyn Display, found_extra: &dyn Display, ) -> &mut Self

pub fn note_trait_signature( &mut self, name: String, signature: String, ) -> &mut Self

pub fn note(&mut self, msg: &str) -> &mut Self

pub fn highlighted_note(&mut self, msg: Vec<Message>) -> &mut Self

pub fn span_note<S: Into<MultiSpan>>(&mut self, sp: S, msg: &str) -> &mut Self

pub fn warn(&mut self, msg: &str) -> &mut Self

pub fn span_warn<S: Into<MultiSpan>>(&mut self, sp: S, msg: &str) -> &mut Self

pub fn help(&mut self, msg: &str) -> &mut Self

pub fn span_help<S: Into<MultiSpan>>(&mut self, sp: S, msg: &str) -> &mut Self

pub fn span_suggestion_short( &mut self, sp: Span, msg: &str, suggestion: String, ) -> &mut Self

👎Deprecated: Use span_suggestion_short_with_applicability

Prints out a message with a suggested edit of the code. If the suggestion is presented inline it will only show the text message and not the text.

See CodeSuggestion for more information.

pub fn span_suggestion( &mut self, sp: Span, msg: &str, suggestion: String, ) -> &mut Self

👎Deprecated: Use span_suggestion_with_applicability

Prints out a message with a suggested edit of the code.

In case of short messages and a simple suggestion, rustc displays it as a label like

“try adding parentheses: (tup.0).1”

The message

• should not end in any punctuation (a : is added automatically)
• should not be a question
• should not contain any parts like “the following”, “as shown”
• may look like “to do xyz, use” or “to do xyz, use abc”
• may contain a name of a function, variable or type, but not whole expressions

See CodeSuggestion for more information.

pub fn multipart_suggestion_with_applicability( &mut self, msg: &str, suggestion: Vec<(Span, String)>, applicability: Applicability, ) -> &mut Self

pub fn multipart_suggestion( &mut self, msg: &str, suggestion: Vec<(Span, String)>, ) -> &mut Self

👎Deprecated: Use multipart_suggestion_with_applicability

pub fn span_suggestions( &mut self, sp: Span, msg: &str, suggestions: Vec<String>, ) -> &mut Self

👎Deprecated: Use span_suggestions_with_applicability

Prints out a message with multiple suggested edits of the code.

pub fn span_suggestion_with_applicability( &mut self, sp: Span, msg: &str, suggestion: String, applicability: Applicability, ) -> &mut Self

This is a suggestion that may contain mistakes or fillers and should be read and understood by a human.

pub fn span_suggestions_with_applicability( &mut self, sp: Span, msg: &str, suggestions: impl Iterator<Item = String>, applicability: Applicability, ) -> &mut Self

pub fn span_suggestion_short_with_applicability( &mut self, sp: Span, msg: &str, suggestion: String, applicability: Applicability, ) -> &mut Self

pub fn set_span<S: Into<MultiSpan>>(&mut self, sp: S) -> &mut Self

pub fn code(&mut self, s: DiagnosticId) -> &mut Self

pub fn get_code(&self) -> Option<DiagnosticId>

pub fn message(&self) -> String

pub fn styled_message(&self) -> &Vec<Message>

pub fn copy_details_not_message(&mut self, from: &Diagnostic)

Used by a lint. Copies over all details but the “main message”.

pub fn sub( &mut self, level: Level, message: &str, span: MultiSpan, render_span: Option<MultiSpan>, )

Convenience function for internal use, clients should use one of the public methods above.

Trait Implementations

impl Archive for Diagnostic

where Level: Archive, Vec<Message>: Archive, Option<DiagnosticId>: Archive, MultiSpan: Archive, Vec<SubDiagnostic>: Archive, Vec<CodeSuggestion>: Archive,

type Archived = ArchivedDiagnostic

The archived representation of this type.

type Resolver = DiagnosticResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for Diagnostic

fn clone(&self) -> Diagnostic

Returns a copy 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<'de> Deserialize<'de> for Diagnostic

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<Diagnostic, __D> for Archived<Diagnostic>

where Level: Archive, Archived<Level>: Deserialize<Level, __D>, Vec<Message>: Archive, Archived<Vec<Message>>: Deserialize<Vec<Message>, __D>, Option<DiagnosticId>: Archive, Archived<Option<DiagnosticId>>: Deserialize<Option<DiagnosticId>, __D>, MultiSpan: Archive, Archived<MultiSpan>: Deserialize<MultiSpan, __D>, Vec<SubDiagnostic>: Archive, Archived<Vec<SubDiagnostic>>: Deserialize<Vec<SubDiagnostic>, __D>, Vec<CodeSuggestion>: Archive, Archived<Vec<CodeSuggestion>>: Deserialize<Vec<CodeSuggestion>, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<Diagnostic, __D::Error>

Deserializes using the given deserializer

impl Hash for Diagnostic

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 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<__S: Fallible + ?Sized> Serialize<__S> for Diagnostic

where Level: Serialize<__S>, Vec<Message>: Serialize<__S>, Option<DiagnosticId>: Serialize<__S>, MultiSpan: Serialize<__S>, Vec<SubDiagnostic>: Serialize<__S>, Vec<CodeSuggestion>: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

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 Eq for Diagnostic

impl StructuralPartialEq for Diagnostic