1use rustc_data_structures::fx::FxIndexSet;
2use rustc_serialize::int_overflow::DebugStrictAdd;
5
6use crate::def_id::{DefIndex, LocalDefId};
7use crate::hygiene::SyntaxContext;
8use crate::{BytePos, SPAN_TRACK, SpanData};
9
10#[derive(Clone, Copy, Eq, PartialEq, Hash)]
81#[rustc_pass_by_value]
82pub struct Span {
83 lo_or_index: u32,
84 len_with_tag_or_marker: u16,
85 ctxt_or_parent_or_marker: u16,
86}
87
88#[derive(Clone, Copy)]
90struct InlineCtxt {
91 lo: u32,
92 len: u16,
93 ctxt: u16,
94}
95
96#[derive(Clone, Copy)]
97struct InlineParent {
98 lo: u32,
99 len_with_tag: u16,
100 parent: u16,
101}
102
103#[derive(Clone, Copy)]
104struct PartiallyInterned {
105 index: u32,
106 ctxt: u16,
107}
108
109#[derive(Clone, Copy)]
110struct Interned {
111 index: u32,
112}
113
114impl InlineCtxt {
115 #[inline]
116 fn data(self) -> SpanData {
117 let len = self.len as u32;
118 debug_assert!(len <= MAX_LEN);
119 SpanData {
120 lo: BytePos(self.lo),
121 hi: BytePos(self.lo.debug_strict_add(len)),
122 ctxt: SyntaxContext::from_u16(self.ctxt),
123 parent: None,
124 }
125 }
126 #[inline]
127 fn span(lo: u32, len: u16, ctxt: u16) -> Span {
128 Span { lo_or_index: lo, len_with_tag_or_marker: len, ctxt_or_parent_or_marker: ctxt }
129 }
130 #[inline]
131 fn from_span(span: Span) -> InlineCtxt {
132 let (lo, len, ctxt) =
133 (span.lo_or_index, span.len_with_tag_or_marker, span.ctxt_or_parent_or_marker);
134 InlineCtxt { lo, len, ctxt }
135 }
136}
137
138impl InlineParent {
139 #[inline]
140 fn data(self) -> SpanData {
141 let len = (self.len_with_tag & !PARENT_TAG) as u32;
142 debug_assert!(len <= MAX_LEN);
143 SpanData {
144 lo: BytePos(self.lo),
145 hi: BytePos(self.lo.debug_strict_add(len)),
146 ctxt: SyntaxContext::root(),
147 parent: Some(LocalDefId { local_def_index: DefIndex::from_u16(self.parent) }),
148 }
149 }
150 #[inline]
151 fn span(lo: u32, len: u16, parent: u16) -> Span {
152 let (lo_or_index, len_with_tag_or_marker, ctxt_or_parent_or_marker) =
153 (lo, PARENT_TAG | len, parent);
154 Span { lo_or_index, len_with_tag_or_marker, ctxt_or_parent_or_marker }
155 }
156 #[inline]
157 fn from_span(span: Span) -> InlineParent {
158 let (lo, len_with_tag, parent) =
159 (span.lo_or_index, span.len_with_tag_or_marker, span.ctxt_or_parent_or_marker);
160 InlineParent { lo, len_with_tag, parent }
161 }
162}
163
164impl PartiallyInterned {
165 #[inline]
166 fn data(self) -> SpanData {
167 SpanData {
168 ctxt: SyntaxContext::from_u16(self.ctxt),
169 ..with_span_interner(|interner| interner.spans[self.index as usize])
170 }
171 }
172 #[inline]
173 fn span(index: u32, ctxt: u16) -> Span {
174 let (lo_or_index, len_with_tag_or_marker, ctxt_or_parent_or_marker) =
175 (index, BASE_LEN_INTERNED_MARKER, ctxt);
176 Span { lo_or_index, len_with_tag_or_marker, ctxt_or_parent_or_marker }
177 }
178 #[inline]
179 fn from_span(span: Span) -> PartiallyInterned {
180 PartiallyInterned { index: span.lo_or_index, ctxt: span.ctxt_or_parent_or_marker }
181 }
182}
183
184impl Interned {
185 #[inline]
186 fn data(self) -> SpanData {
187 with_span_interner(|interner| interner.spans[self.index as usize])
188 }
189 #[inline]
190 fn span(index: u32) -> Span {
191 let (lo_or_index, len_with_tag_or_marker, ctxt_or_parent_or_marker) =
192 (index, BASE_LEN_INTERNED_MARKER, CTXT_INTERNED_MARKER);
193 Span { lo_or_index, len_with_tag_or_marker, ctxt_or_parent_or_marker }
194 }
195 #[inline]
196 fn from_span(span: Span) -> Interned {
197 Interned { index: span.lo_or_index }
198 }
199}
200
201macro_rules! match_span_kind {
205 (
206 $span:expr,
207 InlineCtxt($span1:ident) => $arm1:expr,
208 InlineParent($span2:ident) => $arm2:expr,
209 PartiallyInterned($span3:ident) => $arm3:expr,
210 Interned($span4:ident) => $arm4:expr,
211 ) => {
212 if $span.len_with_tag_or_marker != BASE_LEN_INTERNED_MARKER {
213 if $span.len_with_tag_or_marker & PARENT_TAG == 0 {
214 let $span1 = InlineCtxt::from_span($span);
216 $arm1
217 } else {
218 let $span2 = InlineParent::from_span($span);
220 $arm2
221 }
222 } else if $span.ctxt_or_parent_or_marker != CTXT_INTERNED_MARKER {
223 let $span3 = PartiallyInterned::from_span($span);
225 $arm3
226 } else {
227 let $span4 = Interned::from_span($span);
229 $arm4
230 }
231 };
232}
233
234const MAX_LEN: u32 = 0b0111_1111_1111_1110;
237const MAX_CTXT: u32 = 0b0111_1111_1111_1110;
238const PARENT_TAG: u16 = 0b1000_0000_0000_0000;
239const BASE_LEN_INTERNED_MARKER: u16 = 0b1111_1111_1111_1111;
240const CTXT_INTERNED_MARKER: u16 = 0b1111_1111_1111_1111;
241
242pub const DUMMY_SP: Span =
244 Span { lo_or_index: 0, len_with_tag_or_marker: 0, ctxt_or_parent_or_marker: 0 };
245
246impl Span {
247 #[inline]
248 pub fn new(
249 mut lo: BytePos,
250 mut hi: BytePos,
251 ctxt: SyntaxContext,
252 parent: Option<LocalDefId>,
253 ) -> Self {
254 if lo > hi {
255 std::mem::swap(&mut lo, &mut hi);
256 }
257
258 let (len, ctxt32) = (hi.0 - lo.0, ctxt.as_u32());
260 if len <= MAX_LEN && ctxt32 <= MAX_CTXT {
261 match parent {
262 None => return InlineCtxt::span(lo.0, len as u16, ctxt32 as u16),
263 Some(parent) => {
264 let parent32 = parent.local_def_index.as_u32();
265 if ctxt32 == 0 && parent32 <= MAX_CTXT {
266 return InlineParent::span(lo.0, len as u16, parent32 as u16);
267 }
268 }
269 }
270 }
271
272 let index = |ctxt| {
274 with_span_interner(|interner| interner.intern(&SpanData { lo, hi, ctxt, parent }))
275 };
276 if ctxt32 <= MAX_CTXT {
277 PartiallyInterned::span(index(SyntaxContext::from_u32(u32::MAX)), ctxt32 as u16)
279 } else {
280 Interned::span(index(ctxt))
281 }
282 }
283
284 #[inline]
285 pub fn data(self) -> SpanData {
286 let data = self.data_untracked();
287 if let Some(parent) = data.parent {
288 (*SPAN_TRACK)(parent);
289 }
290 data
291 }
292
293 #[inline]
296 pub fn data_untracked(self) -> SpanData {
297 match_span_kind! {
298 self,
299 InlineCtxt(span) => span.data(),
300 InlineParent(span) => span.data(),
301 PartiallyInterned(span) => span.data(),
302 Interned(span) => span.data(),
303 }
304 }
305
306 #[inline]
308 pub fn from_expansion(self) -> bool {
309 let ctxt = match_span_kind! {
310 self,
311 InlineCtxt(span) => SyntaxContext::from_u16(span.ctxt),
319 InlineParent(_span) => SyntaxContext::root(),
320 PartiallyInterned(span) => SyntaxContext::from_u16(span.ctxt),
321 Interned(_span) => SyntaxContext::from_u16(CTXT_INTERNED_MARKER),
322 };
323 !ctxt.is_root()
324 }
325
326 #[inline]
328 pub fn is_dummy(self) -> bool {
329 if self.len_with_tag_or_marker != BASE_LEN_INTERNED_MARKER {
330 let lo = self.lo_or_index;
332 let len = (self.len_with_tag_or_marker & !PARENT_TAG) as u32;
333 debug_assert!(len <= MAX_LEN);
334 lo == 0 && len == 0
335 } else {
336 let index = self.lo_or_index;
338 let data = with_span_interner(|interner| interner.spans[index as usize]);
339 data.lo == BytePos(0) && data.hi == BytePos(0)
340 }
341 }
342
343 #[inline]
344 pub fn map_ctxt(self, map: impl FnOnce(SyntaxContext) -> SyntaxContext) -> Span {
345 let data = match_span_kind! {
346 self,
347 InlineCtxt(span) => {
348 let new_ctxt = map(SyntaxContext::from_u16(span.ctxt));
351 let new_ctxt32 = new_ctxt.as_u32();
352 return if new_ctxt32 <= MAX_CTXT {
353 InlineCtxt::span(span.lo, span.len, new_ctxt32 as u16)
355 } else {
356 span.data().with_ctxt(new_ctxt)
357 };
358 },
359 InlineParent(span) => span.data(),
360 PartiallyInterned(span) => span.data(),
361 Interned(span) => span.data(),
362 };
363
364 data.with_ctxt(map(data.ctxt))
365 }
366
367 #[inline]
370 fn inline_ctxt(self) -> Result<SyntaxContext, usize> {
371 match_span_kind! {
372 self,
373 InlineCtxt(span) => Ok(SyntaxContext::from_u16(span.ctxt)),
374 InlineParent(_span) => Ok(SyntaxContext::root()),
375 PartiallyInterned(span) => Ok(SyntaxContext::from_u16(span.ctxt)),
376 Interned(span) => Err(span.index as usize),
377 }
378 }
379
380 #[cfg_attr(not(test), rustc_diagnostic_item = "SpanCtxt")]
383 #[inline]
384 pub fn ctxt(self) -> SyntaxContext {
385 self.inline_ctxt()
386 .unwrap_or_else(|index| with_span_interner(|interner| interner.spans[index].ctxt))
387 }
388
389 #[inline]
390 pub fn eq_ctxt(self, other: Span) -> bool {
391 match (self.inline_ctxt(), other.inline_ctxt()) {
392 (Ok(ctxt1), Ok(ctxt2)) => ctxt1 == ctxt2,
393 (Ok(_), Err(_)) | (Err(_), Ok(_)) => false,
397 (Err(index1), Err(index2)) => with_span_interner(|interner| {
398 interner.spans[index1].ctxt == interner.spans[index2].ctxt
399 }),
400 }
401 }
402
403 #[inline]
404 pub fn with_parent(self, parent: Option<LocalDefId>) -> Span {
405 let data = match_span_kind! {
406 self,
407 InlineCtxt(span) => {
408 match parent {
412 None => return self,
413 Some(parent) => {
414 let parent32 = parent.local_def_index.as_u32();
415 if span.ctxt == 0 && parent32 <= MAX_CTXT {
416 return InlineParent::span(span.lo, span.len, parent32 as u16);
417 }
418 }
419 }
420 span.data()
421 },
422 InlineParent(span) => span.data(),
423 PartiallyInterned(span) => span.data(),
424 Interned(span) => span.data(),
425 };
426
427 if let Some(old_parent) = data.parent {
428 (*SPAN_TRACK)(old_parent);
429 }
430 data.with_parent(parent)
431 }
432
433 #[inline]
434 pub fn parent(self) -> Option<LocalDefId> {
435 let interned_parent =
436 |index: u32| with_span_interner(|interner| interner.spans[index as usize].parent);
437 match_span_kind! {
438 self,
439 InlineCtxt(_span) => None,
440 InlineParent(span) => Some(LocalDefId { local_def_index: DefIndex::from_u16(span.parent) }),
441 PartiallyInterned(span) => interned_parent(span.index),
442 Interned(span) => interned_parent(span.index),
443 }
444 }
445}
446
447#[derive(Default)]
448pub(crate) struct SpanInterner {
449 spans: FxIndexSet<SpanData>,
450}
451
452impl SpanInterner {
453 fn intern(&mut self, span_data: &SpanData) -> u32 {
454 let (index, _) = self.spans.insert_full(*span_data);
455 index as u32
456 }
457}
458
459#[inline]
461fn with_span_interner<T, F: FnOnce(&mut SpanInterner) -> T>(f: F) -> T {
462 crate::with_session_globals(|session_globals| f(&mut session_globals.span_interner.lock()))
463}