1use alloc::{
2 borrow::ToOwned,
3 format,
4 string::{String, ToString},
5 vec::Vec,
6};
7use core::{error::Error, fmt, ops::Range};
8
9use crate::{Arena, Handle, UniqueArena};
10
11#[derive(Clone, Copy, Debug, PartialEq, Default)]
13#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
14pub struct Span {
15 start: u32,
16 end: u32,
17}
18
19impl Span {
20 pub const UNDEFINED: Self = Self { start: 0, end: 0 };
21
22 pub const fn new(start: u32, end: u32) -> Self {
26 Span { start, end }
27 }
28
29 pub const fn until(&self, other: &Self) -> Self {
31 Span {
32 start: self.start,
33 end: other.end,
34 }
35 }
36
37 pub fn subsume(&mut self, other: Self) {
40 *self = if !self.is_defined() {
41 other
43 } else if !other.is_defined() {
44 *self
46 } else {
47 Span {
49 start: self.start.min(other.start),
50 end: self.end.max(other.end),
51 }
52 }
53 }
54
55 pub fn total_span<T: Iterator<Item = Self>>(from: T) -> Self {
58 let mut span: Self = Default::default();
59 for other in from {
60 span.subsume(other);
61 }
62 span
63 }
64
65 pub fn to_range(self) -> Option<Range<usize>> {
67 if self.is_defined() {
68 Some(self.start as usize..self.end as usize)
69 } else {
70 None
71 }
72 }
73
74 pub fn is_defined(&self) -> bool {
76 *self != Self::default()
77 }
78
79 pub fn location(&self, source: &str) -> SourceLocation {
81 let prefix = &source[..self.start as usize];
82 let line_number = prefix.matches('\n').count() as u32 + 1;
83 let line_start = prefix.rfind('\n').map(|pos| pos + 1).unwrap_or(0) as u32;
84 let line_position = self.start - line_start + 1;
85
86 SourceLocation {
87 line_number,
88 line_position,
89 offset: self.start,
90 length: self.end - self.start,
91 }
92 }
93}
94
95impl From<Range<usize>> for Span {
96 fn from(range: Range<usize>) -> Self {
97 Span {
98 start: range.start as u32,
99 end: range.end as u32,
100 }
101 }
102}
103
104impl core::ops::Index<Span> for str {
105 type Output = str;
106
107 #[inline]
108 fn index(&self, span: Span) -> &str {
109 &self[span.start as usize..span.end as usize]
110 }
111}
112
113#[derive(Copy, Clone, Debug, PartialEq, Eq)]
122pub struct SourceLocation {
123 pub line_number: u32,
125 pub line_position: u32,
127 pub offset: u32,
129 pub length: u32,
131}
132
133pub type SpanContext = (Span, String);
135
136#[derive(Debug, Clone)]
138pub struct WithSpan<E> {
139 inner: E,
140 spans: Vec<SpanContext>,
141}
142
143impl<E> fmt::Display for WithSpan<E>
144where
145 E: fmt::Display,
146{
147 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
148 self.inner.fmt(f)
149 }
150}
151
152#[cfg(test)]
153impl<E> PartialEq for WithSpan<E>
154where
155 E: PartialEq,
156{
157 fn eq(&self, other: &Self) -> bool {
158 self.inner.eq(&other.inner)
159 }
160}
161
162impl<E> Error for WithSpan<E>
163where
164 E: Error,
165{
166 fn source(&self) -> Option<&(dyn Error + 'static)> {
167 self.inner.source()
168 }
169}
170
171impl<E> WithSpan<E> {
172 pub const fn new(inner: E) -> Self {
174 Self {
175 inner,
176 spans: Vec::new(),
177 }
178 }
179
180 #[allow(clippy::missing_const_for_fn)] pub fn into_inner(self) -> E {
183 self.inner
184 }
185
186 pub const fn as_inner(&self) -> &E {
187 &self.inner
188 }
189
190 pub fn spans(&self) -> impl ExactSizeIterator<Item = &SpanContext> {
192 self.spans.iter()
193 }
194
195 pub fn with_span<S>(mut self, span: Span, description: S) -> Self
197 where
198 S: ToString,
199 {
200 if span.is_defined() {
201 self.spans.push((span, description.to_string()));
202 }
203 self
204 }
205
206 pub fn with_context(self, span_context: SpanContext) -> Self {
208 let (span, description) = span_context;
209 self.with_span(span, description)
210 }
211
212 pub(crate) fn with_handle<T, A: SpanProvider<T>>(self, handle: Handle<T>, arena: &A) -> Self {
215 self.with_context(arena.get_span_context(handle))
216 }
217
218 pub fn into_other<E2>(self) -> WithSpan<E2>
220 where
221 E2: From<E>,
222 {
223 WithSpan {
224 inner: self.inner.into(),
225 spans: self.spans,
226 }
227 }
228
229 pub fn and_then<F, E2>(self, func: F) -> WithSpan<E2>
232 where
233 F: FnOnce(E) -> WithSpan<E2>,
234 {
235 let mut res = func(self.inner);
236 res.spans.extend(self.spans);
237 res
238 }
239
240 pub fn location(&self, source: &str) -> Option<SourceLocation> {
242 if self.spans.is_empty() || source.is_empty() {
243 return None;
244 }
245
246 Some(self.spans[0].0.location(source))
247 }
248
249 pub(crate) fn diagnostic(&self) -> codespan_reporting::diagnostic::Diagnostic<()>
250 where
251 E: Error,
252 {
253 use codespan_reporting::diagnostic::{Diagnostic, Label};
254 let diagnostic = Diagnostic::error()
255 .with_message(self.inner.to_string())
256 .with_labels(
257 self.spans()
258 .map(|&(span, ref desc)| {
259 Label::primary((), span.to_range().unwrap()).with_message(desc.to_owned())
260 })
261 .collect(),
262 )
263 .with_notes({
264 let mut notes = Vec::new();
265 let mut source: &dyn Error = &self.inner;
266 while let Some(next) = Error::source(source) {
267 notes.push(next.to_string());
268 source = next;
269 }
270 notes
271 });
272 diagnostic
273 }
274
275 pub fn emit_to_stderr(&self, source: &str)
277 where
278 E: Error,
279 {
280 self.emit_to_stderr_with_path(source, "wgsl")
281 }
282
283 pub fn emit_to_stderr_with_path(&self, source: &str, path: &str)
285 where
286 E: Error,
287 {
288 use codespan_reporting::term::termcolor::{ColorChoice, StandardStream};
289 use codespan_reporting::{files, term};
290
291 let files = files::SimpleFile::new(path, source);
292 let config = term::Config::default();
293 let writer = StandardStream::stderr(ColorChoice::Auto);
294 term::emit(&mut writer.lock(), &config, &files, &self.diagnostic())
295 .expect("cannot write error");
296 }
297
298 pub fn emit_to_string(&self, source: &str) -> String
300 where
301 E: Error,
302 {
303 self.emit_to_string_with_path(source, "wgsl")
304 }
305
306 pub fn emit_to_string_with_path(&self, source: &str, path: &str) -> String
308 where
309 E: Error,
310 {
311 use codespan_reporting::term::termcolor::NoColor;
312 use codespan_reporting::{files, term};
313
314 let files = files::SimpleFile::new(path, source);
315 let config = term::Config::default();
316 let mut writer = NoColor::new(Vec::new());
317 term::emit(&mut writer, &config, &files, &self.diagnostic()).expect("cannot write error");
318 String::from_utf8(writer.into_inner()).unwrap()
319 }
320}
321
322pub(crate) trait AddSpan: Sized {
324 type Output;
326
327 fn with_span(self) -> Self::Output;
329 fn with_span_static(self, span: Span, description: &'static str) -> Self::Output;
331 fn with_span_context(self, span_context: SpanContext) -> Self::Output;
333 fn with_span_handle<T, A: SpanProvider<T>>(self, handle: Handle<T>, arena: &A) -> Self::Output;
335}
336
337impl<E> AddSpan for E {
338 type Output = WithSpan<Self>;
339
340 fn with_span(self) -> WithSpan<Self> {
341 WithSpan::new(self)
342 }
343
344 fn with_span_static(self, span: Span, description: &'static str) -> WithSpan<Self> {
345 WithSpan::new(self).with_span(span, description)
346 }
347
348 fn with_span_context(self, span_context: SpanContext) -> WithSpan<Self> {
349 WithSpan::new(self).with_context(span_context)
350 }
351
352 fn with_span_handle<T, A: SpanProvider<T>>(
353 self,
354 handle: Handle<T>,
355 arena: &A,
356 ) -> WithSpan<Self> {
357 WithSpan::new(self).with_handle(handle, arena)
358 }
359}
360
361pub(crate) trait SpanProvider<T> {
363 fn get_span(&self, handle: Handle<T>) -> Span;
364 fn get_span_context(&self, handle: Handle<T>) -> SpanContext {
365 match self.get_span(handle) {
366 x if !x.is_defined() => (Default::default(), "".to_string()),
367 known => (
368 known,
369 format!("{} {:?}", core::any::type_name::<T>(), handle),
370 ),
371 }
372 }
373}
374
375impl<T> SpanProvider<T> for Arena<T> {
376 fn get_span(&self, handle: Handle<T>) -> Span {
377 self.get_span(handle)
378 }
379}
380
381impl<T> SpanProvider<T> for UniqueArena<T> {
382 fn get_span(&self, handle: Handle<T>) -> Span {
383 self.get_span(handle)
384 }
385}
386
387pub(crate) trait MapErrWithSpan<E, E2>: Sized {
390 type Output: Sized;
392
393 fn map_err_inner<F, E3>(self, func: F) -> Self::Output
394 where
395 F: FnOnce(E) -> WithSpan<E3>,
396 E2: From<E3>;
397}
398
399impl<T, E, E2> MapErrWithSpan<E, E2> for Result<T, WithSpan<E>> {
400 type Output = Result<T, WithSpan<E2>>;
401
402 fn map_err_inner<F, E3>(self, func: F) -> Result<T, WithSpan<E2>>
403 where
404 F: FnOnce(E) -> WithSpan<E3>,
405 E2: From<E3>,
406 {
407 self.map_err(|e| e.and_then(func).into_other::<E2>())
408 }
409}
410
411#[test]
412fn span_location() {
413 let source = "12\n45\n\n89\n";
414 assert_eq!(
415 Span { start: 0, end: 1 }.location(source),
416 SourceLocation {
417 line_number: 1,
418 line_position: 1,
419 offset: 0,
420 length: 1
421 }
422 );
423 assert_eq!(
424 Span { start: 1, end: 2 }.location(source),
425 SourceLocation {
426 line_number: 1,
427 line_position: 2,
428 offset: 1,
429 length: 1
430 }
431 );
432 assert_eq!(
433 Span { start: 2, end: 3 }.location(source),
434 SourceLocation {
435 line_number: 1,
436 line_position: 3,
437 offset: 2,
438 length: 1
439 }
440 );
441 assert_eq!(
442 Span { start: 3, end: 5 }.location(source),
443 SourceLocation {
444 line_number: 2,
445 line_position: 1,
446 offset: 3,
447 length: 2
448 }
449 );
450 assert_eq!(
451 Span { start: 4, end: 6 }.location(source),
452 SourceLocation {
453 line_number: 2,
454 line_position: 2,
455 offset: 4,
456 length: 2
457 }
458 );
459 assert_eq!(
460 Span { start: 5, end: 6 }.location(source),
461 SourceLocation {
462 line_number: 2,
463 line_position: 3,
464 offset: 5,
465 length: 1
466 }
467 );
468 assert_eq!(
469 Span { start: 6, end: 7 }.location(source),
470 SourceLocation {
471 line_number: 3,
472 line_position: 1,
473 offset: 6,
474 length: 1
475 }
476 );
477 assert_eq!(
478 Span { start: 7, end: 8 }.location(source),
479 SourceLocation {
480 line_number: 4,
481 line_position: 1,
482 offset: 7,
483 length: 1
484 }
485 );
486 assert_eq!(
487 Span { start: 8, end: 9 }.location(source),
488 SourceLocation {
489 line_number: 4,
490 line_position: 2,
491 offset: 8,
492 length: 1
493 }
494 );
495 assert_eq!(
496 Span { start: 9, end: 10 }.location(source),
497 SourceLocation {
498 line_number: 4,
499 line_position: 3,
500 offset: 9,
501 length: 1
502 }
503 );
504 assert_eq!(
505 Span { start: 10, end: 11 }.location(source),
506 SourceLocation {
507 line_number: 5,
508 line_position: 1,
509 offset: 10,
510 length: 1
511 }
512 );
513}