Struct rustc_ap_rustc_session::parse::ParseSess

pub struct ParseSess {
    pub span_diagnostic: Handler,
    pub unstable_features: UnstableFeatures,
    pub config: CrateConfig,
    pub edition: Edition,
    pub missing_fragment_specifiers: Lock<FxHashSet<Span>>,
    pub raw_identifier_spans: Lock<Vec<Span>>,
    pub included_mod_stack: Lock<Vec<PathBuf>>,
    pub buffered_lints: Lock<Vec<BufferedEarlyLint>>,
    pub ambiguous_block_expr_parse: Lock<FxHashMap<Span, Span>>,
    pub injected_crate_name: Once<Symbol>,
    pub gated_spans: GatedSpans,
    pub reached_eof: Lock<bool>,
    // some fields omitted
}

Info about a parsing session.

Fields

span_diagnostic: Handler

unstable_features: UnstableFeatures

config: CrateConfig

edition: Edition

missing_fragment_specifiers: Lock<FxHashSet<Span>>

raw_identifier_spans: Lock<Vec<Span>>

Places where raw identifiers were used. This is used for feature-gating raw identifiers.

included_mod_stack: Lock<Vec<PathBuf>>

Used to determine and report recursive module inclusions.

buffered_lints: Lock<Vec<BufferedEarlyLint>>

ambiguous_block_expr_parse: Lock<FxHashMap<Span, Span>>

Contains the spans of block expressions that could have been incomplete based on the operation token that followed it, but that the parser cannot identify without further analysis.

injected_crate_name: Once<Symbol>

gated_spans: GatedSpans

reached_eof: Lock<bool>

The parser has reached Eof due to an unclosed brace. Used to silence unnecessary errors.

Methods

impl ParseSess

pub fn new(file_path_mapping: FilePathMapping) -> Self

pub fn with_span_handler(handler: Handler, source_map: Lrc<SourceMap>) -> Self

pub fn with_silent_emitter() -> Self

pub fn source_map(&self) -> &SourceMap

pub fn buffer_lint(
    &self,
    lint: &'static Lint,
    span: impl Into<MultiSpan>,
    node_id: NodeId,
    msg: &str
)

pub fn buffer_lint_with_diagnostic(
    &self,
    lint: &'static Lint,
    span: impl Into<MultiSpan>,
    node_id: NodeId,
    msg: &str,
    diagnostic: BuiltinLintDiagnostics
)

pub fn expr_parentheses_needed(
    &self,
    err: &mut DiagnosticBuilder,
    span: Span,
    alt_snippet: Option<String>
)

Extend an error with a suggestion to wrap an expression with parentheses to allow the parser to continue parsing the following operation as part of the same expression.