Struct rustc_parse::lexer::StringReader

struct StringReader<'a> {
    sess: &'a ParseSess,
    start_pos: BytePos,
    pos: BytePos,
    end_src_index: usize,
    src: &'a str,
    override_span: Option<Span>,
}

Fields

sess: &'a ParseSess

start_pos: BytePos

Initial position, read-only.

pos: BytePos

The absolute offset within the source_map of the current character.

end_src_index: usize

Stop reading src at this index.

src: &'a str

Source text to tokenize.

override_span: Option<Span>

Implementations

impl<'a> StringReader<'a>

pub(super) fn into_token_trees(
    self
) -> (PResult<'a, TokenStream>, Vec<UnmatchedBrace>)

impl<'a> StringReader<'a>

fn mk_sp(&self, lo: BytePos, hi: BytePos) -> Span

fn next_token(&mut self) -> (Spacing, Token)

Returns the next token, and info about preceding whitespace, if any.

fn fatal_span(&self, sp: Span, m: &str) -> FatalError

Report a fatal lexical error with a given span.

fn err_span(&self, sp: Span, m: &str)

Report a lexical error with a given span.

fn fatal_span_(&self, from_pos: BytePos, to_pos: BytePos, m: &str) -> FatalError

Report a fatal error spanning [from_pos, to_pos).

fn err_span_(&self, from_pos: BytePos, to_pos: BytePos, m: &str)

Report a lexical error spanning [from_pos, to_pos).

fn struct_fatal_span_char(
    &self,
    from_pos: BytePos,
    to_pos: BytePos,
    m: &str,
    c: char
) -> DiagnosticBuilder<'a>

fn lint_unicode_text_flow(&self, start: BytePos)

Detect usages of Unicode codepoints changing the direction of the text on screen and loudly complain about it.

fn cook_lexer_token(
    &self,
    token: TokenKind,
    start: BytePos
) -> Option<TokenKind>

Turns simple rustc_lexer::TokenKind enum into a rich rustc_ast::TokenKind. This turns strings into interned symbols and runs additional validation.

fn cook_doc_comment(
    &self,
    content_start: BytePos,
    content: &str,
    comment_kind: CommentKind,
    doc_style: DocStyle
) -> TokenKind

fn cook_lexer_literal(
    &self,
    start: BytePos,
    suffix_start: BytePos,
    kind: LiteralKind
) -> (LitKind, Symbol)

fn src_index(&self, pos: BytePos) -> usize

fn str_from(&self, start: BytePos) -> &str

Slice of the source text from start up to but excluding self.pos, meaning the slice does not include the character self.ch.

fn symbol_from_to(&self, start: BytePos, end: BytePos) -> Symbol

As symbol_from, with an explicit endpoint.

fn str_from_to(&self, start: BytePos, end: BytePos) -> &str

Slice of the source text spanning from start up to but excluding end.

fn report_raw_str_error(&self, start: BytePos, opt_err: Option<RawStrError>)

fn report_non_started_raw_string(&self, start: BytePos, bad_char: char) -> !

fn report_unterminated_raw_string(
    &self,
    start: BytePos,
    n_hashes: usize,
    possible_offset: Option<usize>,
    found_terminators: usize
) -> !

fn report_unknown_prefix(&self, start: BytePos)

fn report_too_many_hashes(&self, start: BytePos, found: usize) -> !

Note: It was decided to not add a test case, because it would be too big. https://github.com/rust-lang/rust/pull/50296#issuecomment-392135180

fn validate_literal_escape(
    &self,
    mode: Mode,
    content_start: BytePos,
    content_end: BytePos,
    prefix_len: u32,
    postfix_len: u32
)

fn validate_int_literal(
    &self,
    base: Base,
    content_start: BytePos,
    content_end: BytePos
)

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: 56 bytes