Major changes

- Add Error trait
- Use Option<Box<dyn Error>>
- Update Responder to return a result
  - Update all core implementations

Author: the10thWiz

core/lib/src/catcher/types.rs

@@ -1,22 +1,94 @@
-use transient::{Any, CanRecoverFrom, Co, Downcast};
+use either::Either;
+use transient::{Any, CanRecoverFrom, Inv, Downcast, Transience};
+use crate::{http::Status, Request, Response};
 #[doc(inline)]
 pub use transient::{Static, Transient, TypeId};
 
-pub type ErasedError<'r> = Box<dyn Any<Co<'r>> + Send + Sync + 'r>;
-pub type ErasedErrorRef<'r> = dyn Any<Co<'r>> + Send + Sync + 'r;
+/// Polyfill for trait upcasting to [`Any`]
+pub trait AsAny<Tr: Transience>: Any<Tr> + Sealed {
+    /// The actual upcast
+    fn as_any(&self) -> &dyn Any<Tr>;
+    /// convience typeid of the inner typeid
+    fn trait_obj_typeid(&self) -> TypeId;
+}
+
+use sealed::Sealed;
+mod sealed {
+    use transient::{Any, Inv, TypeId};
+
+    use super::AsAny;
+
+    pub trait Sealed {}
+    impl<'r, T: Any<Inv<'r>>> Sealed for T { }
+    impl<'r, T: Any<Inv<'r>>> AsAny<Inv<'r>> for T {
+        fn as_any(&self) -> &dyn Any<Inv<'r>> {
+            self
+        }
+        fn trait_obj_typeid(&self) -> transient::TypeId {
+            TypeId::of::<T>()
+        }
+    }
+}
+
+/// This is the core of typed catchers. If an error type (returned by
+/// FromParam, FromRequest, FromForm, FromData, or Responder) implements
+/// this trait, it can be caught by a typed catcher. (TODO) This trait
+/// can be derived.
+pub trait Error<'r>: AsAny<Inv<'r>> + Send + Sync + 'r {
+    /// Generates a default response for this type (or forwards to a default catcher)
+    #[allow(unused_variables)]
+    fn respond_to(&self, request: &'r Request<'_>) -> Result<Response<'r>, Status> {
+        Err(Status::InternalServerError)
+    }
+    
+    /// A descriptive name of this error type. Defaults to the type name.
+    fn name(&self) -> &'static str { std::any::type_name::<Self>() }
+
+    /// The error that caused this error. Defaults to None.
+    ///
+    /// # Warning
+    /// A typed catcher will not attempt to follow the source of an error
+    /// more than once.
+    fn source(&self) -> Option<&dyn Error<'r>> { None }
+
+    /// Status code
+    fn status(&self) -> Status { Status::InternalServerError }
+}
 
-pub fn default_error_type<'r>() -> ErasedError<'r> {
-    Box::new(())
+impl<'r> Error<'r> for std::convert::Infallible {  }
+impl<'r, L: Error<'r>, R: Error<'r>> Error<'r> for Either<L, R> {
+    fn respond_to(&self, request: &'r Request<'_>) -> Result<Response<'r>, Status> {
+        match self {
+            Self::Left(v) => v.respond_to(request),
+            Self::Right(v) => v.respond_to(request),
+        }
+    }
+
+    fn name(&self) -> &'static str { std::any::type_name::<Self>() }
+
+    fn source(&self) -> Option<&dyn Error<'r>> { 
+        match self {
+            Self::Left(v) => v.source(),
+            Self::Right(v) => v.source(),
+        }
+    }
+
+    fn status(&self) -> Status {
+        match self {
+            Self::Left(v) => v.status(),
+            Self::Right(v) => v.status(),
+        }
+    }
 }
 
-pub fn downcast<'a, 'r, T: Transient + 'r>(v: &'a ErasedErrorRef<'r>) -> Option<&'a T>
-    where T::Transience: CanRecoverFrom<Co<'r>>
+pub fn downcast<'a, 'r, T: Transient + 'r>(v: &'a dyn Error<'r>) -> Option<&'a T>
+    where T::Transience: CanRecoverFrom<Inv<'r>>
 {
-    v.downcast_ref()
+    v.as_any().downcast_ref()
 }
 
-/// Upcasts a value to `ErasedError`, falling back to a default if it doesn't implement
-/// `Transient`
+/// Upcasts a value to `Box<dyn Error<'r>>`, falling back to a default if it doesn't implement
+/// `Error`
 #[doc(hidden)]
 #[macro_export]
 macro_rules! resolve_typed_catcher {
@@ -26,9 +98,6 @@ macro_rules! resolve_typed_catcher {
 
         Resolve::new($T).cast()
     });
-    () => ({
-        $crate::catcher::default_error_type()
-    });
 }
 
 pub use resolve_typed_catcher;
@@ -61,56 +130,56 @@ pub mod resolution {
     pub trait DefaultTypeErase<'r>: Sized {
         const SPECIALIZED: bool = false;
 
-        fn cast(self) -> ErasedError<'r> { Box::new(()) }
+        fn cast(self) -> Option<Box<dyn Error<'r>>> { None }
     }
 
     impl<'r, T: 'r> DefaultTypeErase<'r> for Resolve<'r, T> {}
 
     /// "Specialized" "implementation" of `Transient` for `T: Transient`. This is
     /// what Rust will resolve `Resolve<T>::item` to when `T: Transient`.
-    impl<'r, T: Transient + Send + Sync + 'r> Resolve<'r, T>
-        where T::Transience: CanTranscendTo<Co<'r>>
+    impl<'r, T: Error<'r> + Transient> Resolve<'r, T>
+        where T::Transience: CanTranscendTo<Inv<'r>>
     {
         pub const SPECIALIZED: bool = true;
 
-        pub fn cast(self) -> ErasedError<'r> { Box::new(self.0) }
+        pub fn cast(self) -> Option<Box<dyn Error<'r>>> { Some(Box::new(self.0))}
     }
 }
 
-#[cfg(test)]
-mod test {
-    // use std::any::TypeId;
+// #[cfg(test)]
+// mod test {
+//     // use std::any::TypeId;
 
-    use transient::{Transient, TypeId};
+//     use transient::{Transient, TypeId};
 
-    use super::resolution::{Resolve, DefaultTypeErase};
+//     use super::resolution::{Resolve, DefaultTypeErase};
 
-    struct NotAny;
-    #[derive(Transient)]
-    struct YesAny;
+//     struct NotAny;
+//     #[derive(Transient)]
+//     struct YesAny;
 
-    #[test]
-    fn check_can_determine() {
-        let not_any = Resolve::new(NotAny).cast();
-        assert_eq!(not_any.type_id(), TypeId::of::<()>());
+//     // #[test]
+//     // fn check_can_determine() {
+//     //     let not_any = Resolve::new(NotAny).cast();
+//     //     assert_eq!(not_any.type_id(), TypeId::of::<()>());
 
-        let yes_any = Resolve::new(YesAny).cast();
-        assert_ne!(yes_any.type_id(), TypeId::of::<()>());
-    }
+//     //     let yes_any = Resolve::new(YesAny).cast();
+//     //     assert_ne!(yes_any.type_id(), TypeId::of::<()>());
+//     // }
 
-    // struct HasSentinel<T>(T);
-
-    // #[test]
-    // fn parent_works() {
-    //     let child = resolve!(YesASentinel, HasSentinel<YesASentinel>);
-    //     assert!(child.type_name.ends_with("YesASentinel"));
-    //     assert_eq!(child.parent.unwrap(), TypeId::of::<HasSentinel<YesASentinel>>());
-    //     assert!(child.specialized);
-
-    //     let not_a_direct_sentinel = resolve!(HasSentinel<YesASentinel>);
-    //     assert!(not_a_direct_sentinel.type_name.contains("HasSentinel"));
-    //     assert!(not_a_direct_sentinel.type_name.contains("YesASentinel"));
-    //     assert!(not_a_direct_sentinel.parent.is_none());
-    //     assert!(!not_a_direct_sentinel.specialized);
-    // }
-}
+//     // struct HasSentinel<T>(T);
+
+//     // #[test]
+//     // fn parent_works() {
+//     //     let child = resolve!(YesASentinel, HasSentinel<YesASentinel>);
+//     //     assert!(child.type_name.ends_with("YesASentinel"));
+//     //     assert_eq!(child.parent.unwrap(), TypeId::of::<HasSentinel<YesASentinel>>());
+//     //     assert!(child.specialized);
+
+//     //     let not_a_direct_sentinel = resolve!(HasSentinel<YesASentinel>);
+//     //     assert!(not_a_direct_sentinel.type_name.contains("HasSentinel"));
+//     //     assert!(not_a_direct_sentinel.type_name.contains("YesASentinel"));
+//     //     assert!(not_a_direct_sentinel.parent.is_none());
+//     //     assert!(!not_a_direct_sentinel.specialized);
+//     // }
+// }

core/lib/src/data/capped.rs

@@ -205,7 +205,8 @@ use crate::response::{self, Responder};
 use crate::request::Request;
 
 impl<'r, 'o: 'r, T: Responder<'r, 'o>> Responder<'r, 'o> for Capped<T> {
-    fn respond_to(self, request: &'r Request<'_>) -> response::Result<'o> {
+    type Error = T::Error;
+    fn respond_to(self, request: &'r Request<'_>) -> response::Outcome<'o, Self::Error> {
         self.value.respond_to(request)
     }
 }

core/lib/src/fs/named_file.rs

@@ -4,8 +4,9 @@ use std::ops::{Deref, DerefMut};
 
 use tokio::fs::{File, OpenOptions};
 
+use crate::outcome::try_outcome;
 use crate::request::Request;
-use crate::response::{self, Responder};
+use crate::response::{self, Responder, Outcome};
 use crate::http::ContentType;
 
 /// A [`Responder`] that sends file data with a Content-Type based on its
@@ -152,15 +153,16 @@ impl NamedFile {
 /// you would like to stream a file with a different Content-Type than that
 /// implied by its extension, use a [`File`] directly.
 impl<'r> Responder<'r, 'static> for NamedFile {
-    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
-        let mut response = self.1.respond_to(req)?;
+    type Error = std::convert::Infallible;
+    fn respond_to(self, req: &'r Request<'_>) -> Outcome<'static, Self::Error> {
+        let mut response = try_outcome!(self.1.respond_to(req));
         if let Some(ext) = self.0.extension() {
             if let Some(ct) = ContentType::from_extension(&ext.to_string_lossy()) {
                 response.set_header(ct);
             }
         }
 
-        Ok(response)
+        Outcome::Success(response)
     }
 }
 

core/lib/src/fs/server.rs

@@ -205,7 +205,7 @@ impl Handler for FileServer {
 
             if segments.is_empty() {
                 let file = NamedFile::open(&self.root).await;
-                return file.respond_to(req).or_forward((data, Status::NotFound));
+                return file.respond_to(req).ok().or_forward((data, Status::NotFound, None));
             } else {
                 return Outcome::forward(data, Status::NotFound);
             }
@@ -227,19 +227,20 @@ impl Handler for FileServer {
 
                     return Redirect::permanent(normal)
                         .respond_to(req)
-                        .or_forward((data, Status::InternalServerError));
+                        .ok()
+                        .or_forward((data, Status::InternalServerError, None));
                 }
 
                 if !options.contains(Options::Index) {
                     return Outcome::forward(data, Status::NotFound);
                 }
 
                 let index = NamedFile::open(p.join("index.html")).await;
-                index.respond_to(req).or_forward((data, Status::NotFound))
+                index.respond_to(req).ok().or_forward((data, Status::NotFound, None))
             },
             Some(p) => {
                 let file = NamedFile::open(p).await;
-                file.respond_to(req).or_forward((data, Status::NotFound))
+                file.respond_to(req).ok().or_forward((data, Status::NotFound, None))
             }
             None => Outcome::forward(data, Status::NotFound),
         }