Struct Span 

pub struct Span<'a> {
    pub file: &'a str,
    pub bytes: Range<usize>,
    pub expanded_from: Option<&'a Span<'a>>,
    pub included_from: Option<&'a Span<'a>>,
}

A representation of a unique location in a source file

If the file was included from another file (using the `include directive), Span::included_from will reference the Span of the include directive

If the Span is part of a `define directive, each expanded text macro will have the original Span of the (now expanded) macro, with Span::expanded_from referencing the original token (in the `define directive) before expansion

Fields

file: &'a str

bytes: Range<usize>

expanded_from: Option<&'a Span<'a>>

included_from: Option<&'a Span<'a>>

Implementations

impl<'a> Span<'a>

pub fn compare(&self, other: &Span<'a>) -> SpanRelation

Compare two Spans, returning the relationship of the first relative to the second

let span1 = Span {
    file: "test",
    bytes: (0..2),
    expanded_from: None,
    included_from: None
};
let span2 = Span {
    file: "test",
    bytes: (6..8),
    expanded_from: None,
    included_from: None
};
assert_eq!(span1.compare(&span2), SpanRelation::Earlier)

Expanded Spans will be compared starting at their expansion point, and working backwards through #defines. Included Spans will be compared starting at their first #include and working through the include hierarchy to their final token. If a Span is included with an `include directive AND expanded from a `define directive, the former is used before the latter.

pub const fn expansion_depth(&self) -> usize

How many preprocessor macros this Span was expanded from

pub const fn inclusion_depth(&self) -> usize

How many `include macros this Span was included with

Trait Implementations

impl<'a> Clone for Span<'a>

fn clone(&self) -> Span<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Span<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Span<'a>

fn default() -> Span<'a>

Returns the “default value” for a type.

impl<'a> Eq for Span<'a>

impl<'a> PartialEq for Span<'a>

fn eq(&self, other: &Span<'a>) -> 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<'a> StructuralPartialEq for Span<'a>