Struct Range 

#[non_exhaustive]
pub struct Range {
    pub span: Range<usize>,
    pub start: Position,
    pub end: Position,
    pub origin_path: Option<Arc<PathBuf>>,
}

Represents a location in source code (start and end positions)

Carries an optional origin_path identifying the source file the range refers to. For ranges built directly by the parser this is None; ranges produced by include resolution (lex_core::includes) carry the canonical path of the file they came from. The field is metadata: it does not affect parsing, formatting, or any structural operation, but it is consulted by file-reference resolution and diagnostics so that information attached to nodes from an included file points at the authoring location, not the post-merge one.

Range is #[non_exhaustive]: external code must construct via Range::new (or builders such as with_origin) rather than struct literals, so future metadata fields can be added without a breaking API change.

Equality and hashing are positional only — origin_path is intentionally excluded from PartialEq/Hash. Two ranges with the same span and positions are equal regardless of which file they came from. This matches what is preserved through serde (origin_path is #[serde(skip)]), so a value can round-trip through JSON without breaking equality.

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.

span: Range<usize>

start: Position

end: Position

origin_path: Option<Arc<PathBuf>>

Optional path of the file this range was authored in.

None for ranges that have not been touched by include resolution. Currently skipped from (de)serialization because Arc<T> deserialization requires serde’s opt-in rc feature; the field is metadata and is not part of any wire format today. When a use case needs origin info on the wire, switch to a custom (de)serialization that emits the path as a string.

Implementations

impl Range

pub fn new(span: ByteRange<usize>, start: Position, end: Position) -> Self

pub fn with_origin(self, path: Arc<PathBuf>) -> Self

Builder: attach an origin path to this range.

Intended use: the include resolver, after parsing each loaded file, walks the resulting tree and stamps the file’s canonical path on every range. Direct parser output should leave this None.

pub fn origin(&self) -> Option<&Path>

Borrow the origin path, if any.

pub fn contains(&self, pos: Position) -> bool

Check if a position is contained within this location

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

Check if another location overlaps with this location

pub fn bounding_box<'a, I>(ranges: I) -> Option<Range>

where I: Iterator<Item = &'a Range>,

Build a bounding box that contains all provided ranges.

The result’s origin_path is Some(p) only when every input range shares the same origin p; mixed-origin inputs (or any None mixed with Some) yield None. This avoids reporting one file’s origin on coordinates that came from another file — relevant after include resolution, when a parent node may aggregate children from the host file and from spliced-in files.

Trait Implementations

impl Clone for Range

fn clone(&self) -> Range

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Range

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

Formats the value using the given formatter.

impl Default for Range

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Range

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Range

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

Formats the value using the given formatter.

impl Hash for Range

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

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 Range

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Range