1mod io;
13pub use io::{IoFailure, io_error};
14
15#[macro_export]
21macro_rules! error_sources {
22 ($kind:ty, patterns $($pattern:pat => $cause:expr),+ $(,)?) => {
23 impl ::core::error::Error for $kind {
24 fn source(&self) -> Option<&(dyn ::core::error::Error + 'static)> {
25 match self {
26 $($pattern => Some($cause),)+
27 _ => None,
28 }
29 }
30 }
31 };
32 ($kind:ty, native $method:ident) => {
33 impl ::core::error::Error for $kind {
34 fn source(&self) -> Option<&(dyn ::core::error::Error + 'static)> {
35 self.$method()
36 .map(|cause| cause as &dyn ::core::error::Error)
37 }
38 }
39 };
40 ($kind:ty, $($variant:ident),+ $(,)?) => {
41 impl ::core::error::Error for $kind {
42 fn source(&self) -> Option<&(dyn ::core::error::Error + 'static)> {
43 match self {
44 $(Self::$variant(cause) => Some(cause),)+
45 _ => None,
46 }
47 }
48 }
49 };
50}
51
52pub trait StructuredError {
62 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>);
65}
66
67pub trait NativeError: std::error::Error + StructuredError + Send + Sync {}
71impl<T: std::error::Error + StructuredError + Send + Sync> NativeError for T {}
72
73impl StructuredError for core::convert::Infallible {
74 fn visit<'error>(&'error self, _visitor: &mut dyn ErrorVisitor<'error>) {
75 unreachable!("an Infallible error has no value to inspect")
78 }
79}
80
81impl StructuredError for core::fmt::Error {
82 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
83 visitor.variant("std-format");
84 }
85}
86
87impl StructuredError for std::collections::TryReserveError {
88 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
89 visitor.variant("std-try-reserve");
92 }
93}
94
95impl StructuredError for core::num::TryFromIntError {
96 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
97 visitor.variant("integer-conversion-range");
100 }
101}
102
103impl StructuredError for core::num::IntErrorKind {
104 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
105 let name = match self {
106 Self::Empty => Some("empty"),
107 Self::InvalidDigit => Some("invalid-digit"),
108 Self::PosOverflow => Some("positive-overflow"),
109 Self::NegOverflow => Some("negative-overflow"),
110 Self::Zero => Some("zero"),
111 _ => None,
112 };
113 visitor.variant("std-integer-kind");
114 visitor.value(
115 Some("name"),
116 name.map_or(ErrorValue::Absent, ErrorValue::Code),
117 );
118 visitor.value(
121 Some("native_discriminant"),
122 ErrorValue::Unsigned(*self as u128),
123 );
124 }
125}
126
127impl StructuredError for core::num::ParseIntError {
128 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
129 visitor.variant("std-integer-parse");
130 visitor.value(Some("kind"), ErrorValue::Cause(self.kind()));
131 }
132}
133
134impl StructuredError for core::str::Utf8Error {
135 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
136 visitor.variant("std-utf8");
137 visitor.value(
138 Some("valid_up_to"),
139 ErrorValue::ByteCount(self.valid_up_to() as u128),
140 );
141 visitor.value(
142 Some("error_len"),
143 self.error_len()
144 .map_or(ErrorValue::Absent, |len| ErrorValue::ByteCount(len as u128)),
145 );
146 }
147}
148
149impl StructuredError for std::time::SystemTimeError {
150 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
151 visitor.variant("std-system-time");
152 let duration = self.duration();
153 visitor.value(
154 Some("seconds"),
155 ErrorValue::Unsigned(u128::from(duration.as_secs())),
156 );
157 visitor.value(
158 Some("nanoseconds"),
159 ErrorValue::Unsigned(u128::from(duration.subsec_nanos())),
160 );
161 }
162}
163
164#[must_use]
167pub fn io_error_kind_name(kind: std::io::ErrorKind) -> Option<&'static str> {
168 match kind {
169 std::io::ErrorKind::NotFound => Some("not-found"),
170 std::io::ErrorKind::PermissionDenied => Some("permission-denied"),
171 std::io::ErrorKind::ConnectionRefused => Some("connection-refused"),
172 std::io::ErrorKind::ConnectionReset => Some("connection-reset"),
173 std::io::ErrorKind::HostUnreachable => Some("host-unreachable"),
174 std::io::ErrorKind::NetworkUnreachable => Some("network-unreachable"),
175 std::io::ErrorKind::ConnectionAborted => Some("connection-aborted"),
176 std::io::ErrorKind::NotConnected => Some("not-connected"),
177 std::io::ErrorKind::AddrInUse => Some("address-in-use"),
178 std::io::ErrorKind::AddrNotAvailable => Some("address-not-available"),
179 std::io::ErrorKind::NetworkDown => Some("network-down"),
180 std::io::ErrorKind::BrokenPipe => Some("broken-pipe"),
181 std::io::ErrorKind::AlreadyExists => Some("already-exists"),
182 std::io::ErrorKind::WouldBlock => Some("would-block"),
183 std::io::ErrorKind::NotADirectory => Some("not-a-directory"),
184 std::io::ErrorKind::IsADirectory => Some("is-a-directory"),
185 std::io::ErrorKind::DirectoryNotEmpty => Some("directory-not-empty"),
186 std::io::ErrorKind::ReadOnlyFilesystem => Some("read-only-filesystem"),
187 std::io::ErrorKind::StaleNetworkFileHandle => Some("stale-network-file-handle"),
188 std::io::ErrorKind::InvalidInput => Some("invalid-input"),
189 std::io::ErrorKind::InvalidData => Some("invalid-data"),
190 std::io::ErrorKind::TimedOut => Some("timed-out"),
191 std::io::ErrorKind::WriteZero => Some("write-zero"),
192 std::io::ErrorKind::StorageFull => Some("storage-full"),
193 std::io::ErrorKind::NotSeekable => Some("not-seekable"),
194 std::io::ErrorKind::QuotaExceeded => Some("quota-exceeded"),
195 std::io::ErrorKind::FileTooLarge => Some("file-too-large"),
196 std::io::ErrorKind::ResourceBusy => Some("resource-busy"),
197 std::io::ErrorKind::ExecutableFileBusy => Some("executable-file-busy"),
198 std::io::ErrorKind::Deadlock => Some("deadlock"),
199 std::io::ErrorKind::CrossesDevices => Some("crosses-devices"),
200 std::io::ErrorKind::TooManyLinks => Some("too-many-links"),
201 std::io::ErrorKind::InvalidFilename => Some("invalid-filename"),
202 std::io::ErrorKind::ArgumentListTooLong => Some("argument-list-too-long"),
203 std::io::ErrorKind::Interrupted => Some("interrupted"),
204 std::io::ErrorKind::Unsupported => Some("unsupported"),
205 std::io::ErrorKind::UnexpectedEof => Some("unexpected-eof"),
206 std::io::ErrorKind::OutOfMemory => Some("out-of-memory"),
207 std::io::ErrorKind::Other => Some("other"),
208 _ => None,
209 }
210}
211
212impl StructuredError for std::io::ErrorKind {
213 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
214 visitor.variant("std-io-kind");
219 visit_io_kind_fields(*self, visitor);
220 }
221}
222
223fn visit_io_kind_fields(kind: std::io::ErrorKind, visitor: &mut dyn ErrorVisitor<'_>) {
224 visitor.value(
225 Some("name"),
226 io_error_kind_name(kind).map_or(ErrorValue::Absent, ErrorValue::Code),
227 );
228 visitor.value(
229 Some("native_discriminant"),
230 ErrorValue::Unsigned(kind as u128),
231 );
232}
233
234#[derive(Clone, Copy)]
241pub enum ErrorValue<'error> {
242 Absent,
244 Unsigned(u128),
246 Signed(i128),
248 Boolean(bool),
250 Float32Bits(u32),
252 Float64Bits(u64),
254 Character(char),
256 Code(&'error str),
258 Text(&'error str),
260 Message(&'error str),
262 Iri(&'error str),
264 Bytes(&'error [u8]),
266 ByteCount(u128),
268 Cause(&'error dyn StructuredError),
270 Record(&'error dyn StructuredError),
272 Term(&'error dyn StructuredError),
274}
275
276crate::debug_non_exhaustive!(ErrorValue<'_> {});
279
280pub trait ErrorVisitor<'error> {
287 fn variant(&mut self, code: &'static str);
289
290 fn value(&mut self, name: Option<&'static str>, value: ErrorValue<'error>);
292
293 fn begin_list(&mut self, name: Option<&'static str>, length: usize);
295
296 fn end_list(&mut self);
298
299 fn begin_record(&mut self, name: Option<&'static str>, code: &'static str);
303
304 fn end_record(&mut self);
306}
307
308impl StructuredError for () {
309 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
310 visitor.variant("unit");
311 }
312}
313
314macro_rules! unsigned_evidence {
317 ($($integer:ty => $widen:expr),* $(,)?) => {$ (
318 impl StructuredError for $integer {
319 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
320 visitor.variant("unsigned-evidence");
321 visitor.value(Some("value"), ErrorValue::Unsigned(($widen)(*self)));
322 }
323 }
324 )*};
325}
326unsigned_evidence!(u32 => u128::from, usize => |value: usize| value as u128);
327
328impl StructuredError for str {
329 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
330 visitor.variant("text-value");
331 visitor.value(Some("text"), ErrorValue::Text(self));
332 }
333}
334
335impl StructuredError for String {
336 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
337 self.as_str().visit(visitor);
338 }
339}
340
341impl<First: StructuredError, Second: StructuredError> StructuredError for (First, Second) {
342 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
343 let (first, second) = self;
344 visitor.variant("pair");
345 visitor.value(Some("first"), ErrorValue::Record(first));
346 visitor.value(Some("second"), ErrorValue::Record(second));
347 }
348}
349
350impl<T: StructuredError + ?Sized> StructuredError for &T {
351 fn visit<'error>(&'error self, visitor: &mut dyn ErrorVisitor<'error>) {
352 T::visit(*self, visitor);
353 }
354}
355
356pub fn visit_list<'error>(
361 visitor: &mut dyn ErrorVisitor<'error>,
362 name: Option<&'static str>,
363 values: impl ExactSizeIterator<Item = ErrorValue<'error>>,
364) {
365 visitor.begin_list(name, values.len());
366 for value in values {
367 visitor.value(None, value);
368 }
369 visitor.end_list();
370}
371
372#[macro_export]
435macro_rules! error_visit {
436 (
437 @tuple $this:ident ($($member:ident),* $(,)?) => $code:literal {
438 $($field:literal => $kind:ident $(($value:expr))?),* $(,)?
439 }
440 ) => {
441 fn visit<'error>(
442 &'error $this,
443 visitor: &mut dyn $crate::error::ErrorVisitor<'error>,
444 ) {
445 let Self($($member),*) = $this;
447 visitor.variant($code);
448 $($crate::error_visit!(@field visitor, $field, $kind $(($value))?);)*
449 }
450 };
451 (
452 @record $this:ident { $($member:ident),* $(,)? } => $code:literal {
453 $($field:literal => $kind:ident $(($value:expr))?),* $(,)?
454 }
455 ) => {
456 fn visit<'error>(
457 &'error $this,
458 visitor: &mut dyn $crate::error::ErrorVisitor<'error>,
459 ) {
460 let Self { $($member: _),* } = $this;
463 visitor.variant($code);
464 $($crate::error_visit!(@field visitor, $field, $kind $(($value))?);)*
465 }
466 };
467 (
468 $(
469 $variant:ident
470 $({ $($named:ident),* $(,)? })?
471 $(($($tuple:ident),* $(,)?))?
472 => $code:literal {
473 $($field:literal => $kind:ident $(($value:expr))?),* $(,)?
474 }
475 ),* $(,)?
476 ) => {
477 fn visit<'error>(
478 &'error self,
479 visitor: &mut dyn $crate::error::ErrorVisitor<'error>,
480 ) {
481 match self {
482 $(Self::$variant $({ $($named),* })? $(($($tuple),*))? => {
483 visitor.variant($code);
484 $($crate::error_visit!(@field visitor, $field, $kind $(($value))?);)*
485 }),*
486 }
487 }
488 };
489 (@field $visitor:ident, $field:literal, List($value:expr)) => {
490 $crate::error::visit_list($visitor, Some($field), $value)
491 };
492 (@field $visitor:ident, $field:literal, Value($value:expr)) => {
493 $visitor.value(Some($field), $value)
494 };
495 (@field $visitor:ident, $field:literal, $kind:ident $(($value:expr))?) => {
496 $visitor.value(Some($field), $crate::error::ErrorValue::$kind $(($value))?)
497 };
498}