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<FxHashMap<Span, NodeId>>,
    pub raw_identifier_spans: Lock<Vec<Span>>,
    pub buffered_lints: Lock<Vec<BufferedEarlyLint>>,
    pub ambiguous_block_expr_parse: Lock<FxHashMap<Span, Span>>,
    pub gated_spans: GatedSpans,
    pub symbol_gallery: SymbolGallery,
    pub reached_eof: Lock<bool>,
    pub env_depinfo: Lock<FxHashSet<(Symbol, Option<Symbol>)>>,
    pub type_ascription_path_suggestions: Lock<FxHashSet<Span>>,
    pub assume_incomplete_release: bool,
    // some fields omitted
}

Info about a parsing session.

Fields

span_diagnostic: Handler

unstable_features: UnstableFeatures

config: CrateConfig

edition: Edition

missing_fragment_specifiers: Lock<FxHashMap<Span, NodeId>>

raw_identifier_spans: Lock<Vec<Span>>

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

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.

gated_spans: GatedSpans

symbol_gallery: SymbolGallery

reached_eof: Lock<bool>

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

env_depinfo: Lock<FxHashSet<(Symbol, Option<Symbol>)>>

Environment variables accessed during the build and their values when they exist.

type_ascription_path_suggestions: Lock<FxHashSet<Span>>

All the type ascriptions expressions that have had a suggestion for likely path typo.

assume_incomplete_release: bool

Whether cfg(version) should treat the current release as incomplete

Implementations

impl ParseSess

pub fn new(file_path_mapping: FilePathMapping) -> Self

Used for testing.

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 clone_source_map(&self) -> Lrc<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.