spanner 0.2.0

map source code positions to easy-to-use structs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use {
	crate::{line_col, Loc, Span},
	::core::{
		fmt::Debug,
		hash::{Hash, Hasher},
		ops::{Index, Range},
	},
};

/// source code for a buffer
pub trait BufferSource: Debug + Default {
	/// the content in the buffer
	///
	/// this should be cheap and always return the same value
	fn source(&self) -> &str;

	/// the name of this buffer
	fn name(&self) -> Option<&str> {
		None
	}
}

impl BufferSource for String {
	fn source(&self) -> &str {
		self
	}
}

/// a buffer containing some source code
#[derive(Debug)]
pub struct Buffer<Src: BufferSource> {
	/// buffer index
	pub(crate) index: u16,
	/// the unique linear index span of this buffer
	pub linear_span: Range<usize>,
	/// [`BufferSource`] for this buffer
	pub src: Src,
	/// the byte offset into this buffer of the start of each line
	pub line_beginnings: Vec<u32>,
}

impl<Src: BufferSource> Buffer<Src> {
	/// where this buffer begins
	pub fn start(&self) -> Loc {
		Loc {
			buf: self.index,
			pos: 0,
		}
	}

	/// where this buffer ends
	#[allow(clippy::cast_possible_truncation, reason = "documented")]
	pub fn end(&self) -> Loc {
		Loc {
			buf: self.index,
			pos: self.len() as u32,
		}
	}

	/// the span of this buffer
	#[allow(clippy::cast_possible_truncation, reason = "documented")]
	pub fn span(&self) -> Span {
		Span {
			start: 0,
			end: self.src.source().len() as u32,
			buf: self.index,
		}
	}

	/// whether the buffer is empty
	pub fn is_empty(&self) -> bool {
		self.len() == 0
	}

	/// the length of the buffer's source code
	pub fn len(&self) -> usize {
		self.src.source().len()
	}

	/// the number of lines in the buffer
	pub fn len_lines(&self) -> usize {
		self.line_beginnings.len()
	}

	/// whether the buffer contains a given location
	#[allow(clippy::cast_possible_truncation, reason = "documented")]
	pub fn contains(&self, loc: Loc) -> bool {
		loc.buf == self.index && loc.pos < self.len() as u32
	}

	/// whether the buffer contains a given span
	#[allow(clippy::cast_possible_truncation, reason = "documented")]
	pub fn contains_span(&self, span: Span) -> bool {
		span.buf == self.index && span.end <= self.len() as u32
	}

	/// slice the source code
	///
	/// this is equivalent to `&buffer[span]`
	pub fn src_slice(&self, span: Span) -> &str {
		&self[span]
	}

	/// find the [`Loc`] of a given [`LineCol`](line_col::LineCol)
	pub fn loc_of(&self, line_col: &line_col::LineCol) -> Loc {
		Loc {
			pos: self.line_beginnings[line_col.line as usize] + line_col.col,
			buf: self.index,
		}
	}

	/// find the [`LineCol`](line_col::LineCol) of a given [`Loc`]
	///
	/// # Panics
	///
	/// if the location is in a different buffer
	pub fn line_col(&self, loc: Loc) -> line_col::LineCol {
		assert_eq!(
			loc.buf, self.index,
			"looking up line_col for a position in a different buffer"
		);
		line_col::find_line_col(&self.line_beginnings[..], loc.pos)
	}
}

impl<Src: BufferSource> Index<Span> for Buffer<Src> {
	type Output = str;

	fn index(&self, span: Span) -> &Self::Output {
		assert_eq!(
			span.buf, self.index,
			"looking up line_col for a position in a different buffer"
		);
		&self.src.source()[span.start as usize..span.end as usize]
	}
}

impl<Src: BufferSource> Hash for Buffer<Src> {
	fn hash<H: Hasher>(&self, state: &mut H) {
		self.index.hash(state);
	}
}

impl<Src: BufferSource> PartialEq for Buffer<Src> {
	fn eq(&self, rhs: &Self) -> bool {
		self.index == rhs.index
	}
}

impl<Src: BufferSource> Eq for Buffer<Src> {}