locspan 0.9.2

Code mapping utility types and traits.
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

use crate::{MaybeSpanned, Span, Spanned};

/// Syntax element location.
///
/// Provides a file identifier (of type `F`) and a [`Span`] in this file.
#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
pub struct Location<F> {
	/// File id.
	pub file: F,

	/// Span.
	pub span: Span,
}

impl<F> Location<F> {
	/// Creates a new location referring to the given `span` in the given `file`.
	#[inline(always)]
	pub fn new(file: F, span: Span) -> Self {
		Self { file, span }
	}

	/// Consumes this location and returns a pair
	/// containing the file and span.
	#[inline(always)]
	pub fn into_parts(self) -> (F, Span) {
		(self.file, self.span)
	}

	/// Consumes this location and returns the file.
	#[inline(always)]
	pub fn into_file(self) -> F {
		self.file
	}

	/// Consumes this location and returns the span.
	#[inline(always)]
	pub fn into_span(self) -> Span {
		self.span
	}

	/// Maps the file identifier.
	#[inline(always)]
	pub fn map<G>(self, f: impl FnOnce(F) -> G) -> Location<G> {
		Location {
			file: f(self.file),
			span: self.span,
		}
	}

	/// Copies the span and borrows the file to create a new `Location<&F>`.
	#[inline(always)]
	pub fn as_ref(&self) -> Location<&F> {
		Location::new(&self.file, self.span)
	}

	/// Converts the location.
	#[inline(always)]
	pub fn cast<G>(self) -> Location<G>
	where
		F: Into<G>,
	{
		Location::new(self.file.into(), self.span)
	}
}

impl<F> Location<F> {
	/// Sets the end of the location span to `end`, and returns itself.
	#[inline(always)]
	pub fn until(mut self, end: usize) -> Self {
		self.span.end = end;
		self
	}

	/// Append `span` to the location span, and returns itself.
	#[inline(always)]
	pub fn with(mut self, span: Span) -> Self {
		self.span.append(span);
		self
	}
}

impl<F: Clone> Location<&F> {
	/// Clones the borrowed file to return a new `Location<F>`.
	#[inline(always)]
	pub fn cloned(&self) -> Location<F> {
		Location::new(self.file.clone(), self.span)
	}
}

/// Value with a location.
pub trait Located {
	type File;

	fn location(&self) -> Location<&Self::File>;
}

impl<F> Located for Location<F> {
	type File = F;

	fn location(&self) -> Location<&Self::File> {
		self.as_ref()
	}
}

impl<T: Located> Spanned for T {
	fn span(&self) -> Span {
		self.location().span
	}
}

/// Value with an optional location.
pub trait MaybeLocated {
	type File;

	fn optional_location(&self) -> Option<Location<&Self::File>>;
}

impl<T: MaybeLocated> MaybeSpanned for T {
	fn optional_span(&self) -> Option<Span> {
		self.optional_location().map(Location::into_span)
	}
}

impl<T: Located> MaybeLocated for T {
	type File = T::File;

	fn optional_location(&self) -> Option<Location<&Self::File>> {
		Some(self.location())
	}
}