Struct Diagnostic

#[repr(C)]
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>,
}

Available on crate features __ecma and __utils only.

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) -> Diagnostic

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

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>(&mut self, span: Span, label: T) -> &mut Diagnostic

where T: Into<String>,

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 Diagnostic

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

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

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

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

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

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

where S: Into<MultiSpan>,

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

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

where S: Into<MultiSpan>,

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

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

where S: Into<MultiSpan>,

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

👎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 Diagnostic

👎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 Diagnostic

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

👎Deprecated: Use multipart_suggestion_with_applicability

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

👎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 Diagnostic

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 Diagnostic

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

pub fn set_span<S>(&mut self, sp: S) -> &mut Diagnostic

where S: Into<MultiSpan>,

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

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,

const COPY_OPTIMIZATION: CopyOptimization<Diagnostic> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

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.

fn resolve( &self, resolver: <Diagnostic as Archive>::Resolver, out: Place<<Diagnostic as Archive>::Archived>, )

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

impl<__C> CheckBytes<__C> for Diagnostic

where __C: Fallible + ?Sized, <__C as Fallible>::Error: Trace, Level: CheckBytes<__C>, Vec<Message>: CheckBytes<__C>, Option<DiagnosticId>: CheckBytes<__C>, MultiSpan: CheckBytes<__C>, Vec<SubDiagnostic>: CheckBytes<__C>, Vec<CodeSuggestion>: CheckBytes<__C>,

unsafe fn check_bytes( value: *const Diagnostic, context: &mut __C, ) -> Result<(), <__C as Fallible>::Error>

Checks whether the given pointer points to a valid value within the given context.

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<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Diagnostic

fn deserialize<__D>( __deserializer: __D, ) -> Result<Diagnostic, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D> Deserialize<Diagnostic, __D> for <Diagnostic as Archive>::Archived

where __D: Fallible + ?Sized, Level: Archive, <Level as Archive>::Archived: Deserialize<Level, __D>, Vec<Message>: Archive, <Vec<Message> as Archive>::Archived: Deserialize<Vec<Message>, __D>, Option<DiagnosticId>: Archive, <Option<DiagnosticId> as Archive>::Archived: Deserialize<Option<DiagnosticId>, __D>, MultiSpan: Archive, <MultiSpan as Archive>::Archived: Deserialize<MultiSpan, __D>, Vec<SubDiagnostic>: Archive, <Vec<SubDiagnostic> as Archive>::Archived: Deserialize<Vec<SubDiagnostic>, __D>, Vec<CodeSuggestion>: Archive, <Vec<CodeSuggestion> as Archive>::Archived: Deserialize<Vec<CodeSuggestion>, __D>,

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

Deserializes using the given deserializer

impl Hash for Diagnostic

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

where __H: Hasher,

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> Serialize<__S> for Diagnostic

where __S: Fallible + ?Sized, 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<<Diagnostic as Archive>::Resolver, <__S as Fallible>::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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Diagnostic

impl StructuralPartialEq for Diagnostic