ndless 0.8.8

use crate::error;
use crate::file_io::sys;
use alloc::boxed::Box;
use core::convert::From;
use core::fmt;
use core::result;

/// A specialized [`Result`](../result/enum.Result.html) type for I/O
/// operations.
///
/// This type is broadly used across [`std::io`] for any operation which may
/// produce an error.
///
/// This typedef is generally used to avoid writing out [`io::Error`] directly and
/// is otherwise a direct mapping to [`Result`].
///
/// While usual Rust style is to import types directly, aliases of [`Result`]
/// often are not, to make it easier to distinguish between them. [`Result`] is
/// generally assumed to be [`std::result::Result`][`Result`], and so users of this alias
/// will generally use `io::Result` instead of shadowing the prelude's import
/// of [`std::result::Result`][`Result`].
///
/// [`std::io`]: ../io/index.html
/// [`io::Error`]: ../io/struct.Error.html
/// [`Result`]: ../result/enum.Result.html
///
/// # Examples
///
/// A convenience function that bubbles an `io::Result` to its caller:
///
/// ```
/// use std::io;
///
/// fn get_string() -> io::Result<String> {
///     let mut buffer = String::new();
///
///     io::stdin().read_line(&mut buffer)?;
///
///     Ok(buffer)
/// }
/// ```
pub type Result<T> = result::Result<T, Error>;

/// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and
/// associated traits.
///
/// Errors mostly originate from the underlying OS, but custom instances of
/// `Error` can be created with crafted error messages and a particular value of
/// [`ErrorKind`].
///
/// [`Read`]: ../io/trait.Read.html
/// [`Write`]: ../io/trait.Write.html
/// [`Seek`]: ../io/trait.Seek.html
/// [`ErrorKind`]: enum.ErrorKind.html
pub struct Error {
	repr: Repr,
}

impl fmt::Debug for Error {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Debug::fmt(&self.repr, f)
	}
}

enum Repr {
	Os(i32),
	Simple(ErrorKind),
	Custom(Box<Custom>),
}

#[derive(Debug)]
struct Custom {
	kind: ErrorKind,
	error: Box<dyn error::Error + Send + Sync>,
}

/// A list specifying general categories of I/O error.
///
/// This list is intended to grow over time and it is not recommended to
/// exhaustively match against it.
///
/// It is used with the [`io::Error`] type.
///
/// [`io::Error`]: struct.Error.html
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[allow(deprecated)]
#[non_exhaustive]
pub enum ErrorKind {
	/// An entity was not found, often a file.
	NotFound,
	/// The operation lacked the necessary privileges to complete.
	PermissionDenied,
	/// The connection was refused by the remote server.
	ConnectionRefused,
	/// The connection was reset by the remote server.
	ConnectionReset,
	/// The connection was aborted (terminated) by the remote server.
	ConnectionAborted,
	/// The network operation failed because it was not connected yet.
	NotConnected,
	/// A socket address could not be bound because the address is already in
	/// use elsewhere.
	AddrInUse,
	/// A nonexistent interface was requested or the requested address was not
	/// local.
	AddrNotAvailable,
	/// The operation failed because a pipe was closed.
	BrokenPipe,
	/// An entity already exists, often a file.
	AlreadyExists,
	/// The operation needs to block to complete, but the blocking operation was
	/// requested to not occur.
	WouldBlock,
	/// A parameter was incorrect.
	InvalidInput,
	/// Data not valid for the operation were encountered.
	///
	/// Unlike [`InvalidInput`], this typically means that the operation
	/// parameters were valid, however the error was caused by malformed
	/// input data.
	///
	/// For example, a function that reads a file into a string will error with
	/// `InvalidData` if the file's contents are not valid UTF-8.
	///
	/// [`InvalidInput`]: #variant.InvalidInput
	InvalidData,
	/// The I/O operation's timeout expired, causing it to be canceled.
	TimedOut,
	/// An error returned when an operation could not be completed because a
	/// call to [`write`] returned [`Ok(0)`].
	///
	/// This typically means that an operation could only succeed if it wrote a
	/// particular number of bytes but only a smaller number of bytes could be
	/// written.
	///
	/// [`write`]: ../../std/io/trait.Write.html#tymethod.write
	/// [`Ok(0)`]: ../../std/io/type.Result.html
	WriteZero,
	/// This operation was interrupted.
	///
	/// Interrupted operations can typically be retried.
	Interrupted,
	/// Any I/O error not part of this list.
	Other,

	/// An error returned when an operation could not be completed because an
	/// "end of file" was reached prematurely.
	///
	/// This typically means that an operation could only succeed if it read a
	/// particular number of bytes but only a smaller number of bytes could be
	/// read.
	UnexpectedEof,
}

impl ErrorKind {
	pub(crate) fn as_str(self) -> &'static str {
		match self {
			ErrorKind::NotFound => "entity not found",
			ErrorKind::PermissionDenied => "permission denied",
			ErrorKind::ConnectionRefused => "connection refused",
			ErrorKind::ConnectionReset => "connection reset",
			ErrorKind::ConnectionAborted => "connection aborted",
			ErrorKind::NotConnected => "not connected",
			ErrorKind::AddrInUse => "address in use",
			ErrorKind::AddrNotAvailable => "address not available",
			ErrorKind::BrokenPipe => "broken pipe",
			ErrorKind::AlreadyExists => "entity already exists",
			ErrorKind::WouldBlock => "operation would block",
			ErrorKind::InvalidInput => "invalid input parameter",
			ErrorKind::InvalidData => "invalid data",
			ErrorKind::TimedOut => "timed out",
			ErrorKind::WriteZero => "write zero",
			ErrorKind::Interrupted => "operation interrupted",
			ErrorKind::Other => "other os error",
			ErrorKind::UnexpectedEof => "unexpected end of file",
		}
	}
}

/// Intended for use for errors not exposed to the user, where allocating onto
/// the heap (for normal construction via Error::new) is too costly.
impl From<ErrorKind> for Error {
	/// Converts an [`ErrorKind`] into an [`Error`].
	///
	/// This conversion allocates a new error with a simple representation of error kind.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::{Error, ErrorKind};
	///
	/// let not_found = ErrorKind::NotFound;
	/// let error = Error::from(not_found);
	/// assert_eq!("entity not found", format!("{}", error));
	/// ```
	///
	/// [`ErrorKind`]: ../../std/io/enum.ErrorKind.html
	/// [`Error`]: ../../std/io/struct.Error.html
	#[inline]
	fn from(kind: ErrorKind) -> Error {
		Error {
			repr: Repr::Simple(kind),
		}
	}
}

impl Error {
	/// Creates a new I/O error from a known kind of error as well as an
	/// arbitrary error payload.
	///
	/// This function is used to generically create I/O errors which do not
	/// originate from the OS itself. The `error` argument is an arbitrary
	/// payload which will be contained in this `Error`.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::{Error, ErrorKind};
	///
	/// // errors can be created from strings
	/// let custom_error = Error::new(ErrorKind::Other, "oh no!");
	///
	/// // errors can also be created from other errors
	/// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);
	/// ```
	pub fn new<E>(kind: ErrorKind, error: E) -> Error
	where
		E: Into<Box<dyn error::Error + Send + Sync>>,
	{
		Self::_new(kind, error.into())
	}

	fn _new(kind: ErrorKind, error: Box<dyn error::Error + Send + Sync>) -> Error {
		Error {
			repr: Repr::Custom(Box::new(Custom { kind, error })),
		}
	}

	/// Returns an error representing the last OS error which occurred.
	///
	/// This function reads the value of `errno` for the target platform (e.g.
	/// `GetLastError` on Windows) and will return a corresponding instance of
	/// `Error` for the error code.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::Error;
	///
	/// println!("last OS error: {:?}", Error::last_os_error());
	/// ```
	pub fn last_os_error() -> Error {
		Error::from_raw_os_error(sys::os::errno() as i32)
	}

	/// Creates a new instance of an `Error` from a particular OS error code.
	///
	/// # Examples
	///
	/// On Linux:
	///
	/// ```
	/// # if cfg!(target_os = "linux") {
	/// use std::io;
	///
	/// let error = io::Error::from_raw_os_error(22);
	/// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
	/// # }
	/// ```
	///
	/// On Windows:
	///
	/// ```
	/// # if cfg!(windows) {
	/// use std::io;
	///
	/// let error = io::Error::from_raw_os_error(10022);
	/// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
	/// # }
	/// ```
	pub fn from_raw_os_error(code: i32) -> Error {
		Error {
			repr: Repr::Os(code),
		}
	}

	/// Returns the OS error that this error represents (if any).
	///
	/// If this `Error` was constructed via `last_os_error` or
	/// `from_raw_os_error`, then this function will return `Some`, otherwise
	/// it will return `None`.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::{Error, ErrorKind};
	///
	/// fn print_os_error(err: &Error) {
	///     if let Some(raw_os_err) = err.raw_os_error() {
	///         println!("raw OS error: {:?}", raw_os_err);
	///     } else {
	///         println!("Not an OS error");
	///     }
	/// }
	///
	/// fn main() {
	///     // Will print "raw OS error: ...".
	///     print_os_error(&Error::last_os_error());
	///     // Will print "Not an OS error".
	///     print_os_error(&Error::new(ErrorKind::Other, "oh no!"));
	/// }
	/// ```
	pub fn raw_os_error(&self) -> Option<i32> {
		match self.repr {
			Repr::Os(i) => Some(i),
			Repr::Custom(..) => None,
			Repr::Simple(..) => None,
		}
	}

	/// Returns a reference to the inner error wrapped by this error (if any).
	///
	/// If this `Error` was constructed via `new` then this function will
	/// return `Some`, otherwise it will return `None`.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::{Error, ErrorKind};
	///
	/// fn print_error(err: &Error) {
	///     if let Some(inner_err) = err.get_ref() {
	///         println!("Inner error: {:?}", inner_err);
	///     } else {
	///         println!("No inner error");
	///     }
	/// }
	///
	/// fn main() {
	///     // Will print "No inner error".
	///     print_error(&Error::last_os_error());
	///     // Will print "Inner error: ...".
	///     print_error(&Error::new(ErrorKind::Other, "oh no!"));
	/// }
	/// ```
	pub fn get_ref(&self) -> Option<&(dyn error::Error + Send + Sync + 'static)> {
		match self.repr {
			Repr::Os(..) => None,
			Repr::Simple(..) => None,
			Repr::Custom(ref c) => Some(&*c.error),
		}
	}

	/// Returns a mutable reference to the inner error wrapped by this error
	/// (if any).
	///
	/// If this `Error` was constructed via `new` then this function will
	/// return `Some`, otherwise it will return `None`.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::{Error, ErrorKind};
	/// use std::{error, fmt};
	/// use std::fmt::Display;
	///
	/// #[derive(Debug)]
	/// struct MyError {
	///     v: String,
	/// }
	///
	/// impl MyError {
	///     fn new() -> MyError {
	///         MyError {
	///             v: "oh no!".to_string()
	///         }
	///     }
	///
	///     fn change_message(&mut self, new_message: &str) {
	///         self.v = new_message.to_string();
	///     }
	/// }
	///
	/// impl error::Error for MyError {
	///     fn description(&self) -> &str { &self.v }
	/// }
	///
	/// impl Display for MyError {
	///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	///         write!(f, "MyError: {}", &self.v)
	///     }
	/// }
	///
	/// fn change_error(mut err: Error) -> Error {
	///     if let Some(inner_err) = err.get_mut() {
	///         inner_err.downcast_mut::<MyError>().unwrap().change_message("I've been changed!");
	///     }
	///     err
	/// }
	///
	/// fn print_error(err: &Error) {
	///     if let Some(inner_err) = err.get_ref() {
	///         println!("Inner error: {}", inner_err);
	///     } else {
	///         println!("No inner error");
	///     }
	/// }
	///
	/// fn main() {
	///     // Will print "No inner error".
	///     print_error(&change_error(Error::last_os_error()));
	///     // Will print "Inner error: ...".
	///     print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));
	/// }
	/// ```
	pub fn get_mut(&mut self) -> Option<&mut (dyn error::Error + Send + Sync + 'static)> {
		match self.repr {
			Repr::Os(..) => None,
			Repr::Simple(..) => None,
			Repr::Custom(ref mut c) => Some(&mut *c.error),
		}
	}

	/// Consumes the `Error`, returning its inner error (if any).
	///
	/// If this `Error` was constructed via `new` then this function will
	/// return `Some`, otherwise it will return `None`.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::{Error, ErrorKind};
	///
	/// fn print_error(err: Error) {
	///     if let Some(inner_err) = err.into_inner() {
	///         println!("Inner error: {}", inner_err);
	///     } else {
	///         println!("No inner error");
	///     }
	/// }
	///
	/// fn main() {
	///     // Will print "No inner error".
	///     print_error(Error::last_os_error());
	///     // Will print "Inner error: ...".
	///     print_error(Error::new(ErrorKind::Other, "oh no!"));
	/// }
	/// ```
	pub fn into_inner(self) -> Option<Box<dyn error::Error + Send + Sync>> {
		match self.repr {
			Repr::Os(..) => None,
			Repr::Simple(..) => None,
			Repr::Custom(c) => Some(c.error),
		}
	}

	/// Returns the corresponding `ErrorKind` for this error.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::{Error, ErrorKind};
	///
	/// fn print_error(err: Error) {
	///     println!("{:?}", err.kind());
	/// }
	///
	/// fn main() {
	///     // Will print "No inner error".
	///     print_error(Error::last_os_error());
	///     // Will print "Inner error: ...".
	///     print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));
	/// }
	/// ```
	pub fn kind(&self) -> ErrorKind {
		match self.repr {
			Repr::Os(code) => sys::decode_error_kind(code),
			Repr::Custom(ref c) => c.kind,
			Repr::Simple(kind) => kind,
		}
	}
}
use cstr_core::NulError;
impl From<NulError> for Error {
	fn from(_: NulError) -> Self {
		ErrorKind::WriteZero.into()
	}
}

impl fmt::Debug for Repr {
	fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
		match *self {
			Repr::Os(code) => fmt
				.debug_struct("Os")
				.field("code", &code)
				.field("kind", &sys::decode_error_kind(code))
				.field("message", &sys::os::error_string(code))
				.finish(),
			Repr::Custom(ref c) => fmt::Debug::fmt(&c, fmt),
			Repr::Simple(kind) => fmt.debug_tuple("Kind").field(&kind).finish(),
		}
	}
}

impl fmt::Display for Error {
	fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
		match self.repr {
			Repr::Os(code) => {
				let detail = sys::os::error_string(code);
				write!(fmt, "{} (os error {})", detail, code)
			}
			Repr::Custom(ref c) => c.error.fmt(fmt),
			Repr::Simple(kind) => write!(fmt, "{}", kind.as_str()),
		}
	}
}

impl error::Error for Error {
	fn description(&self) -> &str {
		match self.repr {
			Repr::Os(..) | Repr::Simple(..) => self.kind().as_str(),
			Repr::Custom(ref c) => c.error.description(),
		}
	}

	#[allow(deprecated)]
	fn cause(&self) -> Option<&dyn error::Error> {
		match self.repr {
			Repr::Os(..) => None,
			Repr::Simple(..) => None,
			Repr::Custom(ref c) => c.error.cause(),
		}
	}

	fn source(&self) -> Option<&(dyn error::Error + 'static)> {
		match self.repr {
			Repr::Os(..) => None,
			Repr::Simple(..) => None,
			Repr::Custom(ref c) => c.error.source(),
		}
	}
}

fn _assert_error_is_sync_send() {
	fn _is_sync_send<T: Sync + Send>() {}
	_is_sync_send::<Error>();
}

#[cfg(test)]
mod test {
	use super::{Custom, Error, ErrorKind, Repr};
	use crate::error;
	use crate::file_io::sys::decode_error_kind;
	use crate::file_io::sys::os::error_string;
	use alloc::boxed::Box;
	use alloc::format;
	use core::fmt;

	#[test]
	fn test_debug_error() {
		let code = 6;
		let msg = error_string(code);
		let kind = decode_error_kind(code);
		let err = Error {
			repr: Repr::Custom(Box::new(Custom {
				kind: ErrorKind::InvalidInput,
				error: Box::new(Error {
					repr: super::Repr::Os(code),
				}),
			})),
		};
		let expected = format!(
			"Custom {{ \
			 kind: InvalidInput, \
			 error: Os {{ \
			 code: {:?}, \
			 kind: {:?}, \
			 message: {:?} \
			 }} \
			 }}",
			code, kind, msg
		);
		assert_eq!(format!("{:?}", err), expected);
	}

	#[test]
	fn test_downcasting() {
		#[derive(Debug)]
		struct TestError;

		impl fmt::Display for TestError {
			fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
				Ok(())
			}
		}

		impl error::Error for TestError {
			fn description(&self) -> &str {
				"asdf"
			}
		}

		// we have to call all of these UFCS style right now since method
		// resolution won't implicitly drop the Send+Sync bounds
		let mut err = Error::new(ErrorKind::Other, TestError);
		assert!(err.get_ref().unwrap().is::<TestError>());
		assert_eq!("asdf", err.get_ref().unwrap().description());
		assert!(err.get_mut().unwrap().is::<TestError>());
		let extracted = err.into_inner().unwrap();
		extracted.downcast::<TestError>().unwrap();
	}
}