Struct Span 

pub struct Span {
    pub start: Position,
    pub end: Position,
    pub start_offset: usize,
    pub end_offset: usize,
}

A span in source text, covering a range between two positions.

Spans are used to indicate the start and end positions of parsed elements. They include both line/column positions and byte offsets for flexible use.

Byte Offset Semantics

Byte offsets use exclusive end semantics (like Rust ranges):

• start_offset..end_offset covers the half-open range [start, end)
• Use source[start_offset..end_offset] to slice the spanned text

Position Semantics

Line and column positions are 1-indexed (the first line is line 1, the first column is column 1). The end position points to the last character in the span (inclusive for display purposes).

Synthetic Spans

Spans created by Span::synthetic() have line: 0 to distinguish them from real source positions. Use is_synthetic() to check.

Fields

start: Position

The start position (line and column, 1-indexed).

end: Position

The end position (line and column, 1-indexed).

start_offset: usize

The start byte offset in the source (0-indexed, inclusive).

end_offset: usize

The end byte offset in the source (0-indexed, exclusive).

Implementations

impl Span

pub const fn synthetic() -> Self

Create a synthetic span for values without source positions.

Uses line 0 to distinguish from real spans (which are 1-indexed). This is useful when converting Value to Expr for deserialization. Check with is_synthetic().

pub const fn is_synthetic(&self) -> bool

Returns true if this is a synthetic span (no source position).

Synthetic spans are created by Span::synthetic() for values converted from Value to AST without original source positions. They use line 0 to distinguish from real spans (which are 1-indexed).

pub fn slice<'a>(&self, source: &'a str) -> &'a str

Slice the given source text using this span’s byte offsets.

Panics

Panics if the byte offsets are out of bounds for the source.

pub fn between(start: &Span, end: &Span) -> Self

Create a span covering from the start of start to the end of end.

This is useful for creating spans that cover a range of tokens, such as the span of a tuple from ( to ).

Trait Implementations

impl Clone for Span

fn clone(&self) -> Span

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Span

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

Formats the value using the given formatter.

impl Default for Span

fn default() -> Span

Returns the “default value” for a type.

impl Display for Span

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

Formats the value using the given formatter.

impl PartialEq for Span

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

impl Eq for Span

impl StructuralPartialEq for Span