Struct rustc_errors::Handler

pub struct Handler {
    pub(crate) flags: HandlerFlags,
    pub(crate) inner: Lock<HandlerInner>,
}

A handler deals with errors and other compiler output. Certain errors (fatal, bug, unimpl) may cause immediate exit, others log errors for later reporting.

Fields

flags: HandlerFlags

inner: Lock<HandlerInner>

Implementations

impl Handler

pub fn with_tty_emitter(
    color_config: ColorConfig,
    can_emit_warnings: bool,
    treat_err_as_bug: Option<NonZeroUsize>,
    sm: Option<Lrc<SourceMap>>
) -> Self

pub fn with_tty_emitter_and_flags(
    color_config: ColorConfig,
    sm: Option<Lrc<SourceMap>>,
    flags: HandlerFlags
) -> Self

pub fn with_emitter(
    can_emit_warnings: bool,
    treat_err_as_bug: Option<NonZeroUsize>,
    emitter: Box<dyn Emitter + Send>
) -> Self

pub fn with_emitter_and_flags(
    emitter: Box<dyn Emitter + Send>,
    flags: HandlerFlags
) -> Self

pub fn can_emit_warnings(&self) -> bool

pub fn reset_err_count(&self)

Resets the diagnostic error count as well as the cached emitted diagnostics.

NOTE: do not call this function from rustc. It is only meant to be called from external tools that want to reuse a Parser cleaning the previously emitted diagnostics as well as the overall count of emitted error diagnostics.

pub fn stash_diagnostic(&self, span: Span, key: StashKey, diag: Diagnostic)

Stash a given diagnostic with the given Span and StashKey as the key for later stealing.

pub fn steal_diagnostic(
    &self,
    span: Span,
    key: StashKey
) -> Option<DiagnosticBuilder<'_>>

Steal a previously stashed diagnostic with the given Span and StashKey as the key.

pub fn emit_stashed_diagnostics(&self)

Emit all stashed diagnostics.

pub fn struct_dummy(&self) -> DiagnosticBuilder<'_>

Construct a dummy builder with Level::Cancelled.

Using this will neither report anything to the user (e.g. a warning), nor will compilation cancel as a result.

pub fn struct_span_warn(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str
) -> DiagnosticBuilder<'_>

Construct a builder at the Warning level at the given span and with the msg.

The builder will be canceled if warnings cannot be emitted.

pub fn struct_span_force_warn(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str
) -> DiagnosticBuilder<'_>

Construct a builder at the Warning level at the given span and with the msg.

This will “force” the warning meaning it will not be canceled even if warnings cannot be emitted.

pub fn struct_span_allow(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str
) -> DiagnosticBuilder<'_>

Construct a builder at the Allow level at the given span and with the msg.

pub fn struct_span_warn_with_code(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str,
    code: DiagnosticId
) -> DiagnosticBuilder<'_>

Construct a builder at the Warning level at the given span and with the msg. Also include a code.

pub fn struct_warn(&self, msg: &str) -> DiagnosticBuilder<'_>

Construct a builder at the Warning level with the msg.

The builder will be canceled if warnings cannot be emitted.

pub fn struct_force_warn(&self, msg: &str) -> DiagnosticBuilder<'_>

Construct a builder at the Warning level with the msg.

This will “force” a warning meaning it will not be canceled even if warnings cannot be emitted.

pub fn struct_allow(&self, msg: &str) -> DiagnosticBuilder<'_>

Construct a builder at the Allow level with the msg.

pub fn struct_span_err(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str
) -> DiagnosticBuilder<'_>

Construct a builder at the Error level at the given span and with the msg.

pub fn struct_span_err_with_code(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str,
    code: DiagnosticId
) -> DiagnosticBuilder<'_>

Construct a builder at the Error level at the given span, with the msg, and code.

pub fn struct_err(&self, msg: &str) -> DiagnosticBuilder<'_>

Construct a builder at the Error level with the msg.

pub fn struct_err_with_code(
    &self,
    msg: &str,
    code: DiagnosticId
) -> DiagnosticBuilder<'_>

Construct a builder at the Error level with the msg and the code.

pub fn struct_span_fatal(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str
) -> DiagnosticBuilder<'_>

Construct a builder at the Fatal level at the given span and with the msg.

pub fn struct_span_fatal_with_code(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str,
    code: DiagnosticId
) -> DiagnosticBuilder<'_>

Construct a builder at the Fatal level at the given span, with the msg, and code.

pub fn struct_fatal(&self, msg: &str) -> DiagnosticBuilder<'_>

Construct a builder at the Error level with the msg.

pub fn struct_help(&self, msg: &str) -> DiagnosticBuilder<'_>

Construct a builder at the Help level with the msg.

pub fn struct_note_without_error(&self, msg: &str) -> DiagnosticBuilder<'_>

Construct a builder at the Note level with the msg.

pub fn span_fatal(&self, span: impl Into<MultiSpan>, msg: &str) -> !

pub fn span_fatal_with_code(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str,
    code: DiagnosticId
) -> !

pub fn span_err(&self, span: impl Into<MultiSpan>, msg: &str)

pub fn span_err_with_code(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str,
    code: DiagnosticId
)

pub fn span_warn(&self, span: impl Into<MultiSpan>, msg: &str)

pub fn span_warn_with_code(
    &self,
    span: impl Into<MultiSpan>,
    msg: &str,
    code: DiagnosticId
)

pub fn span_bug(&self, span: impl Into<MultiSpan>, msg: &str) -> !

pub fn delay_span_bug(&self, span: impl Into<MultiSpan>, msg: &str)

pub fn delay_good_path_bug(&self, msg: &str)

pub fn span_bug_no_panic(&self, span: impl Into<MultiSpan>, msg: &str)

pub fn span_note_without_error(&self, span: impl Into<MultiSpan>, msg: &str)

pub fn span_note_diag(&self, span: Span, msg: &str) -> DiagnosticBuilder<'_>

pub fn fatal(&self, msg: &str) -> FatalError

pub fn err(&self, msg: &str)

pub fn warn(&self, msg: &str)

pub fn note_without_error(&self, msg: &str)

pub fn bug(&self, msg: &str) -> !

pub fn err_count(&self) -> usize

pub fn has_errors(&self) -> bool

pub fn has_errors_or_lint_errors(&self) -> bool

pub fn has_errors_or_delayed_span_bugs(&self) -> bool

pub fn print_error_count(&self, registry: &Registry)

pub fn take_future_breakage_diagnostics(&self) -> Vec<Diagnostic>

pub fn abort_if_errors(&self)

pub fn must_teach(&self, code: &DiagnosticId) -> bool

true if we haven’t taught a diagnostic with this code already. The caller must then teach the user about such a diagnostic.

Used to suppress emitting the same error multiple times with extended explanation when calling -Zteach.

pub fn force_print_diagnostic(&self, db: Diagnostic)

pub fn emit_diagnostic(&self, diagnostic: &Diagnostic)

pub(crate) fn emit_diag_at_span(
    &self,
    diag: Diagnostic,
    sp: impl Into<MultiSpan>
)

pub fn emit_artifact_notification(&self, path: &Path, artifact_type: &str)

pub fn emit_future_breakage_report(&self, diags: Vec<Diagnostic>)

pub fn emit_unused_externs(&self, lint_level: &str, unused_externs: &[&str])

pub fn delay_as_bug(&self, diagnostic: Diagnostic)

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 320 bytes