1use crate::scalar::{line_end, line_start};
2use std::fmt::{self, Display, Write};
3
4pub struct Error {
21 inner: Box<Inner>,
23}
24
25struct Inner {
26 kind: ErrorKind,
27 message: String,
28 position: Option<Position>,
29 source: Option<std::io::Error>,
30}
31
32#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
36#[non_exhaustive]
37pub enum ErrorKind {
38 Syntax,
42 Data,
46 Write,
50 Io,
54}
55
56#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
60pub struct LineColumn {
61 pub line: usize,
65 pub column: usize,
69}
70
71#[derive(Clone, Copy)]
72struct Position {
73 line_column: LineColumn,
74 offset: usize,
75}
76
77impl Error {
78 #[cold]
82 fn unexpected(
83 kind: &str,
84 unexpected: serde_core::de::Unexpected<'_>,
85 expected: &dyn serde_core::de::Expected,
86 ) -> Self {
87 if let serde_core::de::Unexpected::Str(text) = unexpected {
88 let text = crate::abbreviate(text, 40);
89 return Self::data(format!(
90 "invalid {kind}: {}, expected {expected}",
91 serde_core::de::Unexpected::Str(&text)
92 ));
93 }
94
95 Self::data(format!("invalid {kind}: {unexpected}, expected {expected}"))
96 }
97
98 #[cold]
99 pub(crate) fn new(kind: ErrorKind, message: impl Into<String>) -> Self {
100 let mut message = message.into();
102 let sanitized = |character| {
103 if character == '\n' && kind != ErrorKind::Syntax {
104 character
105 } else {
106 sanitize(character)
107 }
108 };
109
110 if let Some((start, _)) = message
111 .char_indices()
112 .find(|&(_, character)| sanitized(character) != character)
113 {
114 let mut clean = String::with_capacity(message.len());
115 clean.push_str(&message[..start]);
116 clean.extend(message[start..].chars().map(sanitized));
117 message = clean;
118 }
119
120 Self {
121 inner: Box::new(Inner {
122 kind,
123 message,
124 position: None,
125 source: None,
126 }),
127 }
128 }
129
130 #[cold]
131 pub(crate) fn syntax(message: impl Into<String>) -> Self {
132 Self::new(ErrorKind::Syntax, message)
133 }
134
135 #[cold]
139 pub(crate) fn data(message: impl Into<String>) -> Self {
140 Self::new(ErrorKind::Data, message)
141 }
142
143 #[cold]
144 pub(crate) fn write(message: impl Into<String>) -> Self {
145 Self::new(ErrorKind::Write, message)
146 }
147
148 #[cold]
149 pub(crate) fn io(error: std::io::Error) -> Self {
150 let mut io = Self::new(ErrorKind::Io, error.to_string());
151 io.inner.source = Some(error);
152 io
153 }
154
155 #[cold]
159 pub(crate) fn at(message: impl Into<String>, source: &str, offset: usize) -> Self {
160 let mut error = Self::syntax(message);
161 error.inner.position = Some(Position::locate(source, offset));
162 error
163 }
164
165 #[must_use]
186 pub fn with_position(message: impl Into<String>, text: &str, offset: usize) -> Self {
187 let mut error = Self::data(message);
188 error.inner.position = Some(Position::locate(text, offset));
189 error
190 }
191
192 #[cold]
196 pub(crate) fn or_at(mut self, source: Option<&str>, offset: Option<usize>) -> Self {
197 if self.inner.position.is_none()
199 && let Some(source) = source
200 && let Some(offset) = offset
201 {
202 self.inner.position = Some(Position::locate(source, offset));
203 }
204
205 self
206 }
207
208 #[must_use]
212 pub const fn kind(&self) -> ErrorKind {
213 self.inner.kind
214 }
215
216 #[must_use]
220 pub const fn message(&self) -> &str {
221 self.inner.message.as_str()
222 }
223
224 #[must_use]
228 pub const fn position(&self) -> Option<LineColumn> {
229 match self.inner.position {
230 Some(position) => Some(position.line_column),
231 None => None,
232 }
233 }
234
235 #[must_use]
239 pub const fn offset(&self) -> Option<usize> {
240 match self.inner.position {
241 Some(position) => Some(position.offset),
242 None => None,
243 }
244 }
245
246 #[must_use]
261 pub fn code_frame(&self, text: &str) -> Option<String> {
262 const CONTEXT_LINES: usize = 2;
263 let position = self.inner.position?;
264
265 let offset = character_start(text, position.offset);
267
268 let line = text.as_bytes()[..offset]
269 .iter()
270 .filter(|&&byte| byte == b'\n')
271 .count() + 1;
272 let mut starts = [0; CONTEXT_LINES + 1];
274 let mut first = CONTEXT_LINES;
275 starts[first] = line_start(text.as_bytes(), offset);
276 while first > 0 && starts[first] > 0 {
277 starts[first - 1] = line_start(text.as_bytes(), starts[first] - 1);
279 first -= 1;
280 }
281 let line_starts = &starts[first..];
282
283 let first_line = line + 1 - line_starts.len();
284 let gutter_width = line.ilog10() as usize + 1;
285 let mut frame = String::with_capacity(384);
286
287 for (index, &line_start) in line_starts.iter().enumerate() {
288 let number = first_line + index;
289 let is_error_line = number == line;
290 let line_end = line_end(text.as_bytes(), line_start);
291 let pointer = if is_error_line {
292 text[line_start..offset].chars().count()
293 } else {
294 0
295 };
296 let (characters, pointer) = clip(&text[line_start..line_end], pointer);
297 let marker = if is_error_line { '>' } else { ' ' };
298
299 if index > 0 {
300 frame.push('\n');
301 }
302
303 write!(frame, "{marker} {number:>gutter_width$} |")
304 .expect("writing to a String does not fail");
305
306 if !characters.is_empty() {
307 frame.push(' ');
308 frame.extend(characters.iter());
309 }
310
311 if is_error_line {
312 write!(frame, "\n {:gutter_width$} | ", "")
313 .expect("writing to a String does not fail");
314 frame.extend(
315 characters[..pointer]
316 .iter()
317 .map(|&character| if character == '\t' { '\t' } else { ' ' }),
318 );
319 frame.push('^');
320 }
321 }
322
323 Some(frame)
324 }
325}
326
327pub(crate) const fn sanitize(character: char) -> char {
331 let is_bidirectional_control = matches!(character, '\u{61C}' | '\u{200E}' | '\u{200F}' | '\u{202A}'..='\u{202E}' | '\u{2066}'..='\u{2069}');
332
333 if (character.is_control() && character != '\t') || is_bidirectional_control {
334 '\u{FFFD}'
335 } else {
336 character
337 }
338}
339
340fn clip(line: &str, pointer: usize) -> (Vec<char>, usize) {
344 const MAX_LINE_WIDTH: usize = 100;
345
346 let length = line.chars().count();
347
348 if length <= MAX_LINE_WIDTH {
349 return (line.chars().map(sanitize).collect(), pointer);
350 }
351
352 let start = pointer
354 .saturating_sub(MAX_LINE_WIDTH / 2)
355 .min(length - MAX_LINE_WIDTH);
356 let end = start + MAX_LINE_WIDTH;
357 let mut clipped = Vec::with_capacity(MAX_LINE_WIDTH + 2);
358
359 if start > 0 {
360 clipped.push('…');
361 }
362
363 clipped.extend(line.chars().skip(start).take(MAX_LINE_WIDTH).map(sanitize));
364
365 if end < length {
366 clipped.push('…');
367 }
368
369 let pointer = pointer - start + usize::from(start > 0);
371 (clipped, pointer)
372}
373
374impl Position {
375 fn locate(source: &str, offset: usize) -> Self {
379 let offset = character_start(source, offset);
380
381 Self {
382 line_column: LineColumn::locate(source, offset),
383 offset,
384 }
385 }
386}
387
388fn character_start(text: &str, offset: usize) -> usize {
392 text.floor_char_boundary(offset)
394}
395
396impl LineColumn {
397 pub(crate) fn locate(source: &str, offset: usize) -> Self {
401 let offset = character_start(source, offset);
402
403 let before = &source.as_bytes()[..offset];
404 let line_start = line_start(source.as_bytes(), offset);
405 let line = before.iter().filter(|&&byte| byte == b'\n').count() + 1;
406
407 let column = before[line_start..]
409 .iter()
410 .filter(|&&byte| byte & 0xC0 != 0x80)
411 .count() + 1;
412
413 Self { line, column }
414 }
415}
416
417impl Display for LineColumn {
421 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
422 write!(formatter, "line {}, column {}", self.line, self.column)
423 }
424}
425
426impl Display for Error {
427 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
428 match self.inner.position {
429 Some(position) => write!(
430 formatter,
431 "{} at {}",
432 self.inner.message, position.line_column
433 ),
434 None => formatter.write_str(&self.inner.message),
435 }
436 }
437}
438
439impl fmt::Debug for Error {
440 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
441 let mut debug = formatter.debug_struct("Error");
442 debug.field("kind", &self.inner.kind);
443 debug.field("message", &self.inner.message);
444
445 if let Some(position) = self.inner.position {
446 debug.field("line", &position.line_column.line);
447 debug.field("column", &position.line_column.column);
448 }
449
450 debug.finish()
451 }
452}
453
454impl std::error::Error for Error {
455 fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
456 self.inner
457 .source
458 .as_ref()
459 .map(|error| error as &(dyn std::error::Error + 'static))
460 }
461}
462
463impl serde_core::de::Error for Error {
464 #[cold]
465 fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
466 let field = crate::abbreviate(field, 40);
467 let error = <serde_core::de::value::Error as serde_core::de::Error>::unknown_field(
468 &field, expected,
469 );
470 Self::data(error.to_string())
471 }
472
473 #[cold]
474 fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self {
475 let variant = crate::abbreviate(variant, 40);
476 let error = <serde_core::de::value::Error as serde_core::de::Error>::unknown_variant(
477 &variant, expected,
478 );
479 Self::data(error.to_string())
480 }
481
482 #[cold]
483 fn custom<T: Display>(message: T) -> Self {
484 Self::data(message.to_string())
485 }
486
487 #[cold]
488 fn invalid_type(
489 unexpected: serde_core::de::Unexpected<'_>,
490 expected: &dyn serde_core::de::Expected,
491 ) -> Self {
492 Self::unexpected("type", unexpected, expected)
493 }
494
495 #[cold]
496 fn invalid_value(
497 unexpected: serde_core::de::Unexpected<'_>,
498 expected: &dyn serde_core::de::Expected,
499 ) -> Self {
500 Self::unexpected("value", unexpected, expected)
501 }
502}
503
504impl serde_core::ser::Error for Error {
505 #[cold]
506 fn custom<T: Display>(message: T) -> Self {
507 Self::write(message.to_string())
508 }
509}