Struct IntegerLit

#[non_exhaustive]
pub struct IntegerLit<B: Buffer> {
    raw: B,
    start_main_part: usize,
    end_main_part: usize,
    base: IntegerBase,
}

An integer literal, e.g. 27, 0x7F, 0b101010u8 or 5_000_000i64.

An integer literal consists of an optional base prefix (0b, 0o, 0x), the main part (digits and underscores), and an optional type suffix (e.g. u64 or i8). See the reference for more information.

Note that integer literals are always positive: the grammar does not contain the minus sign at all. The minus sign is just the unary negate operator, not part of the literal. Which is interesting for cases like - 128i8: here, the literal itself would overflow the specified type (i8 cannot represent 128). That’s why in rustc, the literal overflow check is performed as a lint after parsing, not during the lexing stage. Similarly, IntegerLit::parse does not perform an overflow check.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

raw: B

The raw literal. Grammar: <prefix?><main part><suffix?>.

start_main_part: usize

First index of the main number part (after the base prefix).

end_main_part: usize

First index not part of the main number part.

base: IntegerBase

Parsed raw[..start_main_part].

Implementations

impl<B: Buffer> IntegerLit<B>

pub fn parse(input: B) -> Result<Self, ParseError>

Parses the input as an integer literal. Returns an error if the input is invalid or represents a different kind of literal.

pub fn value<N: FromIntegerLiteral>(&self) -> Option<N>

Performs the actual string to int conversion to obtain the integer value. The optional type suffix of the literal is ignored by this method. This means N does not need to match the type suffix!

Returns None if the literal overflows N.

Hint: u128 can represent all possible values integer literal values, as there are no negative literals (see type docs). Thus you can, for example, safely use lit.value::<u128>().to_string() to get a decimal string. (Technically, Rust integer literals can represent arbitrarily large numbers, but those would be rejected at a later stage by the Rust compiler).

pub fn base(&self) -> IntegerBase

The base of this integer literal.

pub fn raw_main_part(&self) -> &str

The main part containing the digits and potentially _. Do not try to parse this directly as that would ignore the base!

pub fn suffix(&self) -> &str

The optional suffix. Returns "" if the suffix is empty/does not exist.

If you want the type, try IntegerType::from_suffix(lit.suffix()).

pub fn raw_input(&self) -> &str

Returns the raw input that was passed to parse.

pub fn into_raw_input(self) -> B

Returns the raw input that was passed to parse, potentially owned.

impl IntegerLit<&str>

pub fn to_owned(&self) -> IntegerLit<String>

Makes a copy of the underlying buffer and returns the owned version of Self.

Trait Implementations

impl<B: Clone + Buffer> Clone for IntegerLit<B>

fn clone(&self) -> IntegerLit<B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Debug + Buffer> Debug for IntegerLit<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: Buffer> Display for IntegerLit<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: Buffer> From<IntegerLit<B>> for Literal

fn from(l: IntegerLit<B>) -> Self

Converts to this type from the input type.

impl<B: Buffer> From<IntegerLit<B>> for Literal<B>

fn from(src: IntegerLit<B>) -> Self

Converts to this type from the input type.

impl<B: PartialEq + Buffer> PartialEq for IntegerLit<B>

fn eq(&self, other: &IntegerLit<B>) -> 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 TryFrom<&Literal> for IntegerLit<String>

type Error = InvalidToken

The type returned in the event of a conversion error.

fn try_from(src: &Literal) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&TokenTree> for IntegerLit<String>

type Error = InvalidToken

The type returned in the event of a conversion error.

fn try_from(tt: &TokenTree) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Literal> for IntegerLit<String>

type Error = InvalidToken

The type returned in the event of a conversion error.

fn try_from(src: Literal) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<TokenTree> for IntegerLit<String>

type Error = InvalidToken

The type returned in the event of a conversion error.

fn try_from(tt: TokenTree) -> Result<Self, Self::Error>

Performs the conversion.

impl<B: Copy + Buffer> Copy for IntegerLit<B>

impl<B: Eq + Buffer> Eq for IntegerLit<B>

impl<B: Buffer> StructuralPartialEq for IntegerLit<B>