Only handle error values in Error and ErrorKind

littlefs2 error codes are negative.  Non-negative values indicate
success.  This patch updates our error types to enforce this property by
changing the return type of Error::new to Option<Self> and by removing
ErrorKind::Success.

CHANGELOG.md

@@ -31,6 +31,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Refactor error types:
   - Rename `Error` enum to `ErrorKind` and make it non-exhaustive.
   - Add `Error` struct that represents an error code that may or may not map to an `ErrorKind`.
+  - Remove `ErrorKind::Success` and enforce negative values error codes for `Error`.
 
 ### Removed
 

src/io.rs

@@ -125,7 +125,7 @@ pub type Result<T> = core::result::Result<T, Error>;
 /// ```
 /// # use littlefs2::io::{Error, ErrorKind};
 ///
-/// let error = Error::new(-128);
+/// let error = Error::new(-128).unwrap();
 /// assert_ne!(error, ErrorKind::Io);
 ///
 /// let error = Error::from(ErrorKind::Io);
@@ -140,14 +140,20 @@ pub struct Error {
 
 impl Error {
     /// Construct an `Error` from an error code.
-    pub const fn new(code: c_int) -> Self {
-        Self { code }
+    ///
+    /// Error codes that are greater or equals to zero represent success.  In this case, `None` is
+    /// returned.
+    pub const fn new(code: c_int) -> Option<Self> {
+        if code >= 0 {
+            None
+        } else {
+            Some(Self { code })
+        }
     }
 
-    /// Construct an `Error` from an `ErrorKind`.
+    /// Construct an `Error` from an error kind.
     pub const fn from_kind(kind: ErrorKind) -> Self {
         let code = match kind {
-            ErrorKind::Success => ll::lfs_error_LFS_ERR_OK,
             ErrorKind::Io => ll::lfs_error_LFS_ERR_IO,
             ErrorKind::Corruption => ll::lfs_error_LFS_ERR_CORRUPT,
             ErrorKind::NoSuchEntry => ll::lfs_error_LFS_ERR_NOENT,
@@ -163,7 +169,11 @@ impl Error {
             ErrorKind::NoAttribute => ll::lfs_error_LFS_ERR_NOATTR,
             ErrorKind::FilenameTooLong => ll::lfs_error_LFS_ERR_NAMETOOLONG,
         };
-        Self::new(code)
+        if let Some(error) = Self::new(code) {
+            error
+        } else {
+            panic!("error code must be negative");
+        }
     }
 
     /// Return the error code of this error.
@@ -173,8 +183,6 @@ impl Error {
 
     const fn kind(&self) -> Option<ErrorKind> {
         let kind = match self.code {
-            n if n >= 0 => ErrorKind::Success,
-            // negative codes
             ll::lfs_error_LFS_ERR_IO => ErrorKind::Io,
             ll::lfs_error_LFS_ERR_CORRUPT => ErrorKind::Corruption,
             ll::lfs_error_LFS_ERR_NOENT => ErrorKind::NoSuchEntry,
@@ -208,7 +216,7 @@ impl Error {
 ///     "Error { code: -5, kind: Some(Io) }",
 /// );
 /// assert_eq!(
-///     &format!("{:?}", Error::new(-128)),
+///     &format!("{:?}", Error::new(-128).unwrap()),
 ///     "Error { code: -128, kind: None }",
 /// );
 /// ```
@@ -244,8 +252,6 @@ impl PartialEq<ErrorKind> for Error {
 #[derive(Clone, Copy, Debug, PartialEq)]
 #[non_exhaustive]
 pub enum ErrorKind {
-    /// Error code was >=0, operation was successful.
-    Success,
     /// Input / output error occurred.
     Io,
     /// File or filesystem was corrupt.
@@ -283,10 +289,9 @@ pub fn error_code_from<T>(result: Result<T>) -> ll::lfs_error {
 }
 
 pub fn result_from<T>(return_value: T, error_code: ll::lfs_error) -> Result<T> {
-    let error = Error::new(error_code);
-    if error.kind() == Some(ErrorKind::Success) {
-        Ok(return_value)
-    } else {
+    if let Some(error) = Error::new(error_code) {
         Err(error)
+    } else {
+        Ok(return_value)
     }
 }