Struct SourceFile 

pub struct SourceFile { /* private fields */ }

A single source held by a SourceMap: a display name, the owned source text, and the half-open Span the text occupies in the map’s global position space.

The map owns the text so that everything above it can borrow &str for the life of the map without re-reading or copying — a line index, a lexer, a diagnostic renderer all read through this borrow. The span is the file’s footprint in the shared coordinate space: its start is the global offset of the first byte, and a local offset within the file plus that start is the corresponding global position.

Construction is internal; a SourceFile only ever comes from SourceMap::add or SourceMap::source, so its span is always consistent with the map that produced it.

Examples

use source_lang::SourceMap;

let mut map = SourceMap::new();
let id = map.add("greeting.txt", "hello").expect("fits");
let file = map.source(id).expect("just added");

assert_eq!(file.name(), "greeting.txt");
assert_eq!(file.text(), "hello");
assert_eq!(file.span().len(), 5);

Implementations

impl SourceFile

pub fn name(&self) -> &str

Returns the source’s display name — the path or label it was added under.

This is purely a label for diagnostics; the map does not interpret it, so two sources may share a name and still be distinct entries.

Examples

use source_lang::SourceMap;

let mut map = SourceMap::new();
let id = map.add("src/main.rs", "fn main() {}").expect("fits");
assert_eq!(map.source(id).unwrap().name(), "src/main.rs");

pub fn text(&self) -> &str

Returns the source text, borrowed for the life of the map.

Examples

use source_lang::SourceMap;

let mut map = SourceMap::new();
let id = map.add("note.txt", "first line\nsecond line").expect("fits");
let text = map.source(id).unwrap().text();
assert_eq!(text.lines().count(), 2);

pub const fn span(&self) -> Span

Returns the file’s half-open range in the map’s global position space.

span().start() is the global offset of the file’s first byte; the file covers start..start + text().len(). Subtracting start from a global position that falls in this range gives the local offset into text — which is exactly what SourceMap::locate returns.

Examples

use source_lang::SourceMap;

let mut map = SourceMap::new();
let first = map.add("a.txt", "abc").expect("fits");   // global 0..3
let second = map.add("b.txt", "de").expect("fits");   // global 3..5

assert_eq!(map.source(first).unwrap().span().start().to_u32(), 0);
assert_eq!(map.source(second).unwrap().span().start().to_u32(), 3);

Trait Implementations

impl Clone for SourceFile

fn clone(&self) -> SourceFile

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SourceFile

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

Formats the value using the given formatter.

impl Eq for SourceFile

impl PartialEq for SourceFile

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