Struct Span 

pub struct Span {
    pub start: usize,
    pub end: usize,
}

A byte-based span representing a range in source text.

ByteSpan uses byte offsets (not character or line positions) for precise and efficient source location tracking. For LSP communication, use WireRange or convert via LineStartsCache.

Invariants

• start <= end (enforced by constructors, but not at type level for Copy)
• Both start and end are valid byte offsets in the source text
• Spans are half-open intervals: [start, end)

Example

use perl_position_tracking::ByteSpan;

let span = ByteSpan::new(0, 10);
assert_eq!(span.len(), 10);
assert!(!span.is_empty());

// Extract the spanned text
let source = "hello world";
let text = span.slice(source);
assert_eq!(text, "hello worl");

Fields

start: usize

Starting byte offset in the source text (inclusive)

end: usize

Ending byte offset in the source text (exclusive)

Implementations

impl ByteSpan

pub fn new(start: usize, end: usize) -> ByteSpan

Creates a new ByteSpan with the given start and end offsets.

Panics

Panics in debug mode if start > end.

pub const fn empty(pos: usize) -> ByteSpan

Creates an empty span at the given position.

pub fn whole(source: &str) -> ByteSpan

Creates a span covering the entire source text.

pub const fn len(&self) -> usize

Returns the length of this span in bytes.

pub const fn is_empty(&self) -> bool

Returns true if this span is empty (start == end).

pub const fn contains(&self, offset: usize) -> bool

Returns true if this span contains the given byte offset.

pub const fn contains_span(&self, other: ByteSpan) -> bool

Returns true if this span contains the given span entirely.

pub const fn overlaps(&self, other: ByteSpan) -> bool

Returns true if this span overlaps with the given span.

pub fn intersection(&self, other: ByteSpan) -> Option<ByteSpan>

Returns the intersection of two spans, or None if they don’t overlap.

pub fn union(&self, other: ByteSpan) -> ByteSpan

Returns a new span that covers both this span and the given span.

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

Extracts the slice of source text covered by this span.

Panics

Panics if the span is out of bounds for the source text.

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

Safely extracts the slice of source text, returning None if out of bounds.

pub const fn to_range(&self) -> Range<usize>

Converts to a standard Range.

Trait Implementations

impl Clone for ByteSpan

fn clone(&self) -> ByteSpan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ByteSpan

impl Debug for ByteSpan

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

Formats the value using the given formatter.

impl Default for ByteSpan

fn default() -> ByteSpan

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ByteSpan

fn deserialize<__D>( __deserializer: __D, ) -> Result<ByteSpan, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ByteSpan

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

Formats the value using the given formatter.

impl Eq for ByteSpan

impl From<(usize, usize)> for ByteSpan

fn from(_: (usize, usize)) -> ByteSpan

Converts to this type from the input type.

impl From<ByteSpan> for Range

Convert old SourceLocation to Range (for migration)

fn from(loc: ByteSpan) -> Range

Converts to this type from the input type.

impl From<Range<usize>> for ByteSpan

fn from(range: Range<usize>) -> ByteSpan

Converts to this type from the input type.

impl Hash for ByteSpan

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 ByteSpan

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ByteSpan