Enum Spacing

pub enum Spacing {
    Alone,
    Joint,
    JointHidden,
}

Indicates whether a token can join with the following token to form a compound token. Used for conversions to proc_macro::Spacing. Also used to guide pretty-printing, which is where the JointHidden value (which isn’t part of proc_macro::Spacing) comes in useful.

Variants

Alone

The token cannot join with the following token to form a compound token.

In token streams parsed from source code, the compiler will use Alone for any token immediately followed by whitespace, a non-doc comment, or EOF.

When constructing token streams within the compiler, use this for each token that (a) should be pretty-printed with a space after it, or (b) is the last token in the stream. (In the latter case the choice of spacing doesn’t matter because it is never used for the last token. We arbitrarily use Alone.)

Converts to proc_macro::Spacing::Alone, and proc_macro::Spacing::Alone converts back to this.

Joint

The token can join with the following token to form a compound token.

In token streams parsed from source code, the compiler will use Joint for any token immediately followed by punctuation (as determined by Token::is_punct).

When constructing token streams within the compiler, use this for each token that (a) should be pretty-printed without a space after it, and (b) is followed by a punctuation token.

Converts to proc_macro::Spacing::Joint, and proc_macro::Spacing::Joint converts back to this.

JointHidden

The token can join with the following token to form a compound token, but this will not be visible at the proc macro level. (This is what the Hidden means; see below.)

In token streams parsed from source code, the compiler will use JointHidden for any token immediately followed by anything not covered by the Alone and Joint cases: an identifier, lifetime, literal, delimiter, doc comment.

When constructing token streams, use this for each token that (a) should be pretty-printed without a space after it, and (b) is followed by a non-punctuation token.

Converts to proc_macro::Spacing::Alone, but proc_macro::Spacing::Alone converts back to token::Spacing::Alone. Because of that, pretty-printing of TokenStreams produced by proc macros is unavoidably uglier (with more whitespace between tokens) than pretty-printing of TokenStream’s produced by other means (i.e. parsed source code, internally constructed token streams, and token streams produced by declarative macros).

Trait Implementations

impl Clone for Spacing

fn clone(&self) -> Spacing

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Spacing

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

Formats the value using the given formatter.

impl Hash for Spacing

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Spacing

fn eq(&self, other: &Spacing) -> 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 Copy for Spacing

impl Eq for Spacing

impl StructuralPartialEq for Spacing