ref(symcache): Switch to error with kind (#296)

Author: jan-auer

symbolic-cabi/src/core.rs

@@ -335,33 +335,33 @@ impl SymbolicErrorCode {
                 return SymbolicErrorCode::ParseSourceMapError;
             }
 
-            use symbolic::symcache::SymCacheError;
+            use symbolic::symcache::{SymCacheError, SymCacheErrorKind};
             if let Some(error) = error.downcast_ref::<SymCacheError>() {
-                return match error {
-                    SymCacheError::BadFileMagic => SymbolicErrorCode::SymCacheErrorBadFileMagic,
-                    SymCacheError::BadFileHeader(_) => {
+                return match error.kind() {
+                    SymCacheErrorKind::BadFileMagic => SymbolicErrorCode::SymCacheErrorBadFileMagic,
+                    SymCacheErrorKind::BadFileHeader => {
                         SymbolicErrorCode::SymCacheErrorBadFileHeader
                     }
-                    SymCacheError::BadSegment => SymbolicErrorCode::SymCacheErrorBadSegment,
-                    SymCacheError::BadCacheFile => SymbolicErrorCode::SymCacheErrorBadCacheFile,
-                    SymCacheError::UnsupportedVersion => {
+                    SymCacheErrorKind::BadSegment => SymbolicErrorCode::SymCacheErrorBadSegment,
+                    SymCacheErrorKind::BadCacheFile => SymbolicErrorCode::SymCacheErrorBadCacheFile,
+                    SymCacheErrorKind::UnsupportedVersion => {
                         SymbolicErrorCode::SymCacheErrorUnsupportedVersion
                     }
-                    SymCacheError::BadDebugFile(_) => SymbolicErrorCode::SymCacheErrorBadDebugFile,
-                    SymCacheError::MissingDebugSection => {
+                    SymCacheErrorKind::BadDebugFile => SymbolicErrorCode::SymCacheErrorBadDebugFile,
+                    SymCacheErrorKind::MissingDebugSection => {
                         SymbolicErrorCode::SymCacheErrorMissingDebugSection
                     }
-                    SymCacheError::MissingDebugInfo => {
+                    SymCacheErrorKind::MissingDebugInfo => {
                         SymbolicErrorCode::SymCacheErrorMissingDebugInfo
                     }
-                    SymCacheError::UnsupportedDebugKind => {
+                    SymCacheErrorKind::UnsupportedDebugKind => {
                         SymbolicErrorCode::SymCacheErrorUnsupportedDebugKind
                     }
-                    SymCacheError::ValueTooLarge(_) => {
+                    SymCacheErrorKind::ValueTooLarge(_) => {
                         SymbolicErrorCode::SymCacheErrorValueTooLarge
                     }
-                    SymCacheError::WriteFailed(_) => SymbolicErrorCode::SymCacheErrorWriteFailed,
-                    SymCacheError::TooManyValues(_) => {
+                    SymCacheErrorKind::WriteFailed => SymbolicErrorCode::SymCacheErrorWriteFailed,
+                    SymCacheErrorKind::TooManyValues(_) => {
                         SymbolicErrorCode::SymCacheErrorTooManyValues
                     }
                     _ => SymbolicErrorCode::SymCacheErrorUnknown,

symbolic-symcache/src/cache.rs

@@ -2,7 +2,7 @@ use std::fmt;
 
 use symbolic_common::{Arch, AsSelf, DebugId, Language, Name, NameMangling};
 
-use crate::error::SymCacheError;
+use crate::error::{SymCacheError, SymCacheErrorKind};
 use crate::format;
 
 /// A platform independent symbolication cache.
@@ -267,7 +267,7 @@ impl<'a> SymCache<'a> {
             if let Some((line_addr, file_id, line)) = self.run_to_line(fun, addr)? {
                 // A missing file record indicates a bad symcache.
                 let file_record = read_file_record(self.data, self.header.files, file_id)?
-                    .ok_or(SymCacheError::BadCacheFile)?;
+                    .ok_or(SymCacheErrorKind::BadCacheFile)?;
 
                 // The address was found in the function's line records, so use
                 // it directly. This should is the default case for all valid

symbolic-symcache/src/error.rs

@@ -1,3 +1,4 @@
+use std::error::Error;
 use std::fmt;
 
 use thiserror::Error;
@@ -26,55 +27,94 @@ impl fmt::Display for ValueKind {
     }
 }
 
-/// An error returned when handling [`SymCache`](struct.SymCache.html).
+/// The error type for [`SymCacheError`].
 #[non_exhaustive]
-#[derive(Debug, Error)]
-pub enum SymCacheError {
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SymCacheErrorKind {
     /// Invalid magic bytes in the symcache header.
-    #[error("bad symcache magic")]
     BadFileMagic,
 
     /// Invalid flags or fields in the symcache header.
-    #[error("invalid symcache header")]
-    BadFileHeader(#[source] std::io::Error),
+    BadFileHeader,
 
     /// A segment could not be read, likely due to IO errors.
-    #[error("cannot read symcache segment")]
     BadSegment,
 
     /// Contents in the symcache file are malformed.
-    #[error("malformed symcache file")]
     BadCacheFile,
 
     /// The symcache version is not known.
-    #[error("unsupported symcache version")]
     UnsupportedVersion,
 
     /// The `Object` contains invalid data and cannot be converted.
-    #[error("malformed debug info file")]
-    BadDebugFile(#[source] Box<dyn std::error::Error + Send + Sync + 'static>),
+    BadDebugFile,
 
     /// A required debug section is missing in the `Object` file.
-    #[error("missing debug section")]
     MissingDebugSection,
 
     /// The `Object` file was stripped of debug information.
-    #[error("no debug information found in file")]
     MissingDebugInfo,
 
     /// The debug information in the `Object` file is not supported.
-    #[error("unsupported debug information")]
     UnsupportedDebugKind,
 
     /// A value cannot be written to symcache as it overflows the record size.
-    #[error("{0} too large for symcache file format")]
     ValueTooLarge(ValueKind),
 
     /// A value cannot be written to symcache as it overflows the segment counter.
-    #[error("too many {0}s for symcache")]
     TooManyValues(ValueKind),
 
     /// Generic error when writing a symcache, most likely IO.
-    #[error("failed to write symcache")]
-    WriteFailed(#[source] std::io::Error),
+    WriteFailed,
+}
+
+impl fmt::Display for SymCacheErrorKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::BadFileMagic => write!(f, "bad symcache magic"),
+            Self::BadFileHeader => write!(f, "invalid symcache header"),
+            Self::BadSegment => write!(f, "cannot read symcache segment"),
+            Self::BadCacheFile => write!(f, "malformed symcache file"),
+            Self::UnsupportedVersion => write!(f, "unsupported symcache version"),
+            Self::BadDebugFile => write!(f, "malformed debug info file"),
+            Self::MissingDebugSection => write!(f, "missing debug section"),
+            Self::MissingDebugInfo => write!(f, "no debug information found in file"),
+            Self::UnsupportedDebugKind => write!(f, "unsupported debug information"),
+            Self::ValueTooLarge(kind) => write!(f, "{} too large for symcache file format", kind),
+            Self::TooManyValues(kind) => write!(f, "too many {}s for symcache", kind),
+            Self::WriteFailed => write!(f, "failed to write symcache"),
+        }
+    }
+}
+
+/// An error returned when handling [`SymCache`](struct.SymCache.html).
+#[derive(Debug, Error)]
+#[error("{kind}")]
+pub struct SymCacheError {
+    kind: SymCacheErrorKind,
+    #[source]
+    source: Option<Box<dyn Error + Send + Sync + 'static>>,
+}
+
+impl SymCacheError {
+    /// Creates a new SymCache error from a known kind of error as well as an
+    /// arbitrary error payload.
+    pub(crate) fn new<E>(kind: SymCacheErrorKind, source: E) -> Self
+    where
+        E: Into<Box<dyn Error + Send + Sync>>,
+    {
+        let source = Some(source.into());
+        Self { kind, source }
+    }
+
+    /// Returns the corresponding [`SymCacheErrorKind`] for this error.
+    pub fn kind(&self) -> SymCacheErrorKind {
+        self.kind
+    }
+}
+
+impl From<SymCacheErrorKind> for SymCacheError {
+    fn from(kind: SymCacheErrorKind) -> Self {
+        Self { kind, source: None }
+    }
 }

symbolic-symcache/src/format.rs

@@ -7,7 +7,7 @@ use std::marker::PhantomData;
 
 use symbolic_common::{DebugId, Uuid};
 
-use crate::error::SymCacheError;
+use crate::error::{SymCacheError, SymCacheErrorKind};
 
 /// The magic file preamble to identify symcache files.
 pub const SYMCACHE_MAGIC: [u8; 4] = *b"SYMC";
@@ -80,7 +80,8 @@ where
         let offset = self.offset as usize;
         let len = self.len.into() as usize;
         let size = std::mem::size_of::<T>() * len;
-        let slice = get_slice(data, offset, size).map_err(|_| SymCacheError::BadSegment)?;
+        let slice = get_slice(data, offset, size)
+            .map_err(|e| SymCacheError::new(SymCacheErrorKind::BadSegment, e))?;
         Ok(unsafe { std::slice::from_raw_parts(slice.as_ptr() as *const T, len) })
     }
 
@@ -100,7 +101,9 @@ where
     /// Reads an entire binary segment as string.
     pub fn read_str<'a>(&self, data: &'a [u8]) -> Result<&'a str, SymCacheError> {
         let slice = self.read(data)?;
-        Ok(std::str::from_utf8(slice).map_err(|_| SymCacheError::BadSegment)?)
+        let string = std::str::from_utf8(slice)
+            .map_err(|e| SymCacheError::new(SymCacheErrorKind::BadSegment, e))?;
+        Ok(string)
     }
 }
 
@@ -319,20 +322,21 @@ pub struct Header {
 impl Header {
     /// Parses the correct version of the SymCache [`Header`](struct.Header.html).
     pub fn parse(data: &[u8]) -> Result<Self, SymCacheError> {
-        let preamble = get_record::<Preamble>(data, 0).map_err(SymCacheError::BadFileHeader)?;
+        let preamble = get_record::<Preamble>(data, 0)
+            .map_err(|e| SymCacheError::new(SymCacheErrorKind::BadFileHeader, e))?;
 
         if preamble.magic != SYMCACHE_MAGIC {
-            return Err(SymCacheError::BadFileMagic);
+            return Err(SymCacheErrorKind::BadFileMagic.into());
         }
 
         Ok(match preamble.version {
             1 => get_record::<HeaderV1>(data, 0)
-                .map_err(SymCacheError::BadFileHeader)?
+                .map_err(|e| SymCacheError::new(SymCacheErrorKind::BadFileHeader, e))?
                 .into(),
             2..=SYMCACHE_VERSION => get_record::<HeaderV2>(data, 0)
-                .map_err(SymCacheError::BadFileHeader)?
+                .map_err(|e| SymCacheError::new(SymCacheErrorKind::BadFileHeader, e))?
                 .into(),
-            _ => return Err(SymCacheError::UnsupportedVersion),
+            _ => return Err(SymCacheErrorKind::UnsupportedVersion.into()),
         })
     }
 }

symbolic-symcache/src/writer.rs

@@ -8,7 +8,7 @@ use num::FromPrimitive;
 use symbolic_common::{Arch, DebugId, Language};
 use symbolic_debuginfo::{DebugSession, FileInfo, Function, LineInfo, ObjectLike, Symbol};
 
-use crate::error::{SymCacheError, ValueKind};
+use crate::error::{SymCacheError, SymCacheErrorKind, ValueKind};
 use crate::format;
 
 // Performs a shallow check whether this function might contain any lines.
@@ -68,7 +68,7 @@ where
         self.position = position;
         self.writer
             .seek(io::SeekFrom::Start(position))
-            .map_err(SymCacheError::WriteFailed)?;
+            .map_err(|e| SymCacheError::new(SymCacheErrorKind::WriteFailed, e))?;
 
         Ok(())
     }
@@ -78,7 +78,7 @@ where
     fn write_bytes(&mut self, data: &[u8]) -> Result<(), SymCacheError> {
         self.writer
             .write_all(data)
-            .map_err(SymCacheError::WriteFailed)?;
+            .map_err(|e| SymCacheError::new(SymCacheErrorKind::WriteFailed, e))?;
 
         self.position += data.len() as u64;
         Ok(())
@@ -110,7 +110,8 @@ where
         let bytes = unsafe { std::slice::from_raw_parts(data.as_ptr() as *const u8, byte_size) };
 
         let segment_pos = self.position as u32;
-        let segment_len = L::from_usize(data.len()).ok_or(SymCacheError::TooManyValues(kind))?;
+        let segment_len =
+            L::from_usize(data.len()).ok_or(SymCacheErrorKind::TooManyValues(kind))?;
 
         self.write_bytes(bytes)?;
         Ok(format::Seg::new(segment_pos, segment_len))
@@ -205,10 +206,11 @@ where
 
         let session = object
             .debug_session()
-            .map_err(|e| SymCacheError::BadDebugFile(Box::new(e)))?;
+            .map_err(|e| SymCacheError::new(SymCacheErrorKind::BadDebugFile, e))?;
 
         for function in session.functions() {
-            let function = function.map_err(|e| SymCacheError::BadDebugFile(Box::new(e)))?;
+            let function =
+                function.map_err(|e| SymCacheError::new(SymCacheErrorKind::BadDebugFile, e))?;
             writer.add_function(function)?;
         }
 
@@ -372,7 +374,7 @@ where
         }
 
         if self.files.len() >= std::u16::MAX as usize {
-            return Err(SymCacheError::TooManyValues(ValueKind::File));
+            return Err(SymCacheErrorKind::TooManyValues(ValueKind::File).into());
         }
 
         let index = self.files.len() as u16;
@@ -396,7 +398,7 @@ where
 
         // NB: We only use 48 bits to encode symbol offsets in function records.
         if self.symbols.len() >= 0x00ff_ffff {
-            return Err(SymCacheError::TooManyValues(ValueKind::Symbol));
+            return Err(SymCacheErrorKind::TooManyValues(ValueKind::Symbol).into());
         }
 
         // Avoid a potential reallocation by reusing name.
@@ -475,7 +477,7 @@ where
         let symbol_id = self.insert_symbol(function.name.as_str().into())?;
         let comp_dir = self.write_path(function.compilation_dir)?;
         let lang = u8::from_u32(language as u32)
-            .ok_or(SymCacheError::ValueTooLarge(ValueKind::Language))?;
+            .ok_or(SymCacheErrorKind::ValueTooLarge(ValueKind::Language))?;
 
         let mut start_address = function.address;
         let mut lines = function.lines.iter().peekable();
@@ -532,7 +534,7 @@ where
         // functions to the file.
         let index = functions.len();
         if index >= std::u32::MAX as usize {
-            return Err(SymCacheError::ValueTooLarge(ValueKind::Function));
+            return Err(SymCacheErrorKind::ValueTooLarge(ValueKind::Function).into());
         }
 
         // For optimization purposes, remember if all functions appear in order. If not, parent
@@ -600,7 +602,7 @@ where
 
                 let parent_offset = index - parent_index;
                 if parent_offset > std::u16::MAX.into() {
-                    return Err(SymCacheError::ValueTooLarge(ValueKind::ParentOffset));
+                    return Err(SymCacheErrorKind::ValueTooLarge(ValueKind::ParentOffset).into());
                 }
 
                 record.parent_offset = parent_offset as u16;