Major improvements

- Catchers now carry `TypeId` and type name for collision detection
- Transient updated to 0.3, with new derive macro
- Added `Transient` or `Static` implementations for error types
- CI should now pass

Author: the10thWiz

core/codegen/src/attribute/catch/mod.rs

@@ -1,13 +1,24 @@
 mod parse;
 
 use devise::ext::SpanDiagnosticExt;
-use devise::{Spanned, Result};
+use devise::{Diagnostic, Level, Result, Spanned};
 use proc_macro2::{TokenStream, Span};
 
 use crate::http_codegen::Optional;
 use crate::syn_ext::ReturnTypeExt;
 use crate::exports::*;
 
+fn arg_ty(arg: &syn::FnArg) -> Result<&syn::Type> {
+    match arg {
+        syn::FnArg::Receiver(_) => Err(Diagnostic::spanned(
+            arg.span(),
+            Level::Error,
+            "Catcher cannot have self as a parameter"
+        )),
+        syn::FnArg::Typed(syn::PatType {ty, ..})=> Ok(ty.as_ref()),
+    }
+}
+
 pub fn _catch(
     args: proc_macro::TokenStream,
     input: proc_macro::TokenStream
@@ -45,16 +56,17 @@ pub fn _catch(
             syn::FnArg::Receiver(_) => codegen_arg.respanned(fn_arg.span()),
             syn::FnArg::Typed(a) => codegen_arg.respanned(a.ty.span())
         }).rev();
-    let make_error = if catch.function.sig.inputs.len() >= 3 {
+    let (make_error, error_type) = if catch.function.sig.inputs.len() >= 3 {
         let arg = catch.function.sig.inputs.first().unwrap();
-        quote_spanned!(arg.span() => 
+        let ty = arg_ty(arg)?;
+        (quote_spanned!(arg.span() =>
             let #__error = match ::rocket::catcher::downcast(__error_init.as_ref()) {
                 Some(v) => v,
                 None => return #_Result::Err((#__status, __error_init)),
             };
-        )
+        ), quote! {Some((#_catcher::TypeId::of::<#ty>(), ::std::any::type_name::<#ty>()))})
     } else {
-        quote! {}
+        (quote! {}, quote! {None})
     };
 
     // We append `.await` to the function call if this is `async`.
@@ -99,6 +111,7 @@ pub fn _catch(
                 #_catcher::StaticInfo {
                     name: ::core::stringify!(#user_catcher_fn_name),
                     code: #status_code,
+                    error_type: #error_type,
                     handler: monomorphized_function,
                     location: (::core::file!(), ::core::line!(), ::core::column!()),
                 }

core/codegen/src/attribute/catch/parse.rs

@@ -56,6 +56,6 @@ impl Attribute {
             .map_err(|diag| diag.help("`#[catch]` expects a status code int or `default`: \
                         `#[catch(404)]` or `#[catch(default)]`"))?;
 
-        Ok(Attribute { status: status.code.0, function, error: status.error })
+        Ok(Attribute { status: status.code.0, function, error: None })
     }
 }

core/codegen/src/attribute/route/mod.rs

@@ -115,11 +115,15 @@ fn query_decls(route: &Route) -> Option<TokenStream> {
                 );
                 ::rocket::trace::info!(
                     target: concat!("rocket::codegen::route::", module_path!()),
-                    error_type = ::std::any::type_name_of_val(&__error),
+                    error_type = ::std::any::type_name_of_val(&__e),
                     "Forwarding error"
                 );
 
-                return #Outcome::Forward((#__data, #Status::UnprocessableEntity, #resolve_error!(__e)));
+                return #Outcome::Forward((
+                    #__data,
+                    #Status::UnprocessableEntity,
+                    #resolve_error!(__e)
+                ));
             }
 
             (#(#ident.unwrap()),*)
@@ -207,7 +211,11 @@ fn param_guard_decl(guard: &Guard) -> TokenStream {
                         #i
                     );
 
-                    return #Outcome::Forward((#__data, #Status::InternalServerError, #resolve_error!()));
+                    return #Outcome::Forward((
+                        #__data,
+                        #Status::InternalServerError,
+                        #resolve_error!()
+                    ));
                 }
             }
         },
@@ -226,7 +234,8 @@ fn param_guard_decl(guard: &Guard) -> TokenStream {
 
 fn data_guard_decl(guard: &Guard) -> TokenStream {
     let (ident, ty) = (guard.fn_ident.rocketized(), &guard.ty);
-    define_spanned_export!(ty.span() => __req, __data, display_hack, FromData, Outcome, resolve_error);
+    define_spanned_export!(ty.span() =>
+        __req, __data, display_hack, FromData, Outcome, resolve_error);
 
     quote_spanned! { ty.span() =>
         let #ident: #ty = match <#ty as #FromData>::from_data(#__req, #__data).await {
@@ -251,7 +260,7 @@ fn data_guard_decl(guard: &Guard) -> TokenStream {
                     parameter = stringify!(#ident),
                     type_name = stringify!(#ty),
                     reason = %#display_hack!(&__e),
-                    error_type = ::std::any::type_name_of_val(&__error),
+                    error_type = ::std::any::type_name_of_val(&__e),
                     "data guard failed"
                 );
 

core/codegen/tests/catcher.rs

@@ -58,3 +58,23 @@ fn test_status_param() {
         assert_eq!(response.into_string().unwrap(), code.to_string());
     }
 }
+
+#[catch(404)]
+fn bad_req_untyped(_: Status, _: &Request<'_>) -> &'static str { "404" }
+#[catch(404)]
+fn bad_req_string(_: &String, _: Status, _: &Request<'_>) -> &'static str { "404 String" }
+#[catch(404)]
+fn bad_req_tuple(_: &(), _: Status, _: &Request<'_>) -> &'static str { "404 ()" }
+
+#[test]
+fn test_typed_catchers() {
+    fn rocket() -> Rocket<Build> {
+        rocket::build()
+            .register("/", catchers![bad_req_untyped, bad_req_string, bad_req_tuple])
+    }
+
+    // Assert the catchers do not collide. They are only differentiated by their error type.
+    let client = Client::debug(rocket()).unwrap();
+    let response = client.get("/").dispatch();
+    assert_eq!(response.status(), Status::NotFound);
+}

core/http/Cargo.toml

@@ -36,7 +36,7 @@ memchr = "2"
 stable-pattern = "0.1"
 cookie = { version = "0.18", features = ["percent-encode"] }
 state = "0.6"
-transient = { version = "0.2.1" }
+transient = { version = "0.3" }
 
 [dependencies.serde]
 version = "1.0"

core/lib/Cargo.toml

@@ -74,7 +74,7 @@ tokio-stream = { version = "0.1.6", features = ["signal", "time"] }
 cookie = { version = "0.18", features = ["percent-encode"] }
 futures = { version = "0.3.30", default-features = false, features = ["std"] }
 state = "0.6"
-transient = { version = "0.2.1" }
+transient = { version = "0.3" }
 
 # tracing
 tracing = { version = "0.1.40", default-features = false, features = ["std", "attributes"] }

core/lib/src/catcher/catcher.rs

@@ -1,6 +1,8 @@
 use std::fmt;
 use std::io::Cursor;
 
+use transient::TypeId;
+
 use crate::http::uri::Path;
 use crate::http::ext::IntoOwned;
 use crate::response::Response;
@@ -122,6 +124,9 @@ pub struct Catcher {
     /// The catcher's associated error handler.
     pub handler: Box<dyn Handler>,
 
+    /// Catcher error type
+    pub(crate) error_type: Option<(TypeId, &'static str)>,
+
     /// The mount point.
     pub(crate) base: uri::Origin<'static>,
 
@@ -134,10 +139,11 @@ pub struct Catcher {
     pub(crate) location: Option<(&'static str, u32, u32)>,
 }
 
-// The rank is computed as -(number of nonempty segments in base) => catchers
+// The rank is computed as -(number of nonempty segments in base) *2 => catchers
 // with more nonempty segments have lower ranks => higher precedence.
+// Doubled to provide space between for typed catchers.
 fn rank(base: Path<'_>) -> isize {
-    -(base.segments().filter(|s| !s.is_empty()).count() as isize)
+    -(base.segments().filter(|s| !s.is_empty()).count() as isize) * 2
 }
 
 impl Catcher {
@@ -149,22 +155,26 @@ impl Catcher {
     ///
     /// ```rust
     /// use rocket::request::Request;
-    /// use rocket::catcher::{Catcher, BoxFuture, ErasedErrorRef};
+    /// use rocket::catcher::{Catcher, BoxFuture, ErasedError};
     /// use rocket::response::Responder;
     /// use rocket::http::Status;
     ///
-    /// fn handle_404<'r>(status: Status, req: &'r Request<'_>, _e: &ErasedErrorRef<'r>) -> BoxFuture<'r> {
+    /// fn handle_404<'r>(status: Status, req: &'r Request<'_>, _e: ErasedError<'r>)
+    ///    -> BoxFuture<'r>
+    /// {
     ///    let res = (status, format!("404: {}", req.uri()));
-    ///    Box::pin(async move { res.respond_to(req) })
+    ///    Box::pin(async move { res.respond_to(req).map_err(|s| (s, _e)) })
     /// }
     ///
-    /// fn handle_500<'r>(_: Status, req: &'r Request<'_>, _e: &ErasedErrorRef<'r>) -> BoxFuture<'r> {
-    ///     Box::pin(async move{ "Whoops, we messed up!".respond_to(req) })
+    /// fn handle_500<'r>(_: Status, req: &'r Request<'_>, _e: ErasedError<'r>) -> BoxFuture<'r> {
+    ///     Box::pin(async move{ "Whoops, we messed up!".respond_to(req).map_err(|s| (s, _e)) })
     /// }
     ///
-    /// fn handle_default<'r>(status: Status, req: &'r Request<'_>, _e: &ErasedErrorRef<'r>) -> BoxFuture<'r> {
+    /// fn handle_default<'r>(status: Status, req: &'r Request<'_>, _e: ErasedError<'r>)
+    ///    -> BoxFuture<'r>
+    /// {
     ///    let res = (status, format!("{}: {}", status, req.uri()));
-    ///    Box::pin(async move { res.respond_to(req) })
+    ///    Box::pin(async move { res.respond_to(req).map_err(|s| (s, _e)) })
     /// }
     ///
     /// let not_found_catcher = Catcher::new(404, handle_404);
@@ -189,6 +199,7 @@ impl Catcher {
             name: None,
             base: uri::Origin::root().clone(),
             handler: Box::new(handler),
+            error_type: None,
             rank: rank(uri::Origin::root().path()),
             code,
             location: None,
@@ -201,13 +212,15 @@ impl Catcher {
     ///
     /// ```rust
     /// use rocket::request::Request;
-    /// use rocket::catcher::{Catcher, BoxFuture, ErasedErrorRef};
+    /// use rocket::catcher::{Catcher, BoxFuture, ErasedError};
     /// use rocket::response::Responder;
     /// use rocket::http::Status;
     ///
-    /// fn handle_404<'r>(status: Status, req: &'r Request<'_>, _e: &ErasedErrorRef<'r>) -> BoxFuture<'r> {
+    /// fn handle_404<'r>(status: Status, req: &'r Request<'_>, _e: ErasedError<'r>)
+    ///    -> BoxFuture<'r>
+    /// {
     ///    let res = (status, format!("404: {}", req.uri()));
-    ///    Box::pin(async move { res.respond_to(req) })
+    ///    Box::pin(async move { res.respond_to(req).map_err(|s| (s, _e)) })
     /// }
     ///
     /// let catcher = Catcher::new(404, handle_404);
@@ -227,14 +240,16 @@ impl Catcher {
     ///
     /// ```rust
     /// use rocket::request::Request;
-    /// use rocket::catcher::{Catcher, BoxFuture, ErasedErrorRef};
+    /// use rocket::catcher::{Catcher, BoxFuture, ErasedError};
     /// use rocket::response::Responder;
     /// use rocket::http::Status;
     /// # use rocket::uri;
     ///
-    /// fn handle_404<'r>(status: Status, req: &'r Request<'_>, _e: &ErasedErrorRef<'r>) -> BoxFuture<'r> {
+    /// fn handle_404<'r>(status: Status, req: &'r Request<'_>, _e: ErasedError<'r>)
+    ///    -> BoxFuture<'r>
+    /// {
     ///    let res = (status, format!("404: {}", req.uri()));
-    ///    Box::pin(async move { res.respond_to(req) })
+    ///    Box::pin(async move { res.respond_to(req).map_err(|s| (s, _e)) })
     /// }
     ///
     /// let catcher = Catcher::new(404, handle_404);
@@ -281,13 +296,15 @@ impl Catcher {
     ///
     /// ```rust
     /// use rocket::request::Request;
-    /// use rocket::catcher::{Catcher, BoxFuture, ErasedErrorRef};
+    /// use rocket::catcher::{Catcher, BoxFuture, ErasedError};
     /// use rocket::response::Responder;
     /// use rocket::http::Status;
     ///
-    /// fn handle_404<'r>(status: Status, req: &'r Request<'_>, _e: &ErasedErrorRef<'r>) -> BoxFuture<'r> {
+    /// fn handle_404<'r>(status: Status, req: &'r Request<'_>, _e: ErasedError<'r>)
+    ///    -> BoxFuture<'r>
+    /// {
     ///    let res = (status, format!("404: {}", req.uri()));
-    ///    Box::pin(async move { res.respond_to(req) })
+    ///    Box::pin(async move { res.respond_to(req).map_err(|s| (s, _e)) })
     /// }
     ///
     /// let catcher = Catcher::new(404, handle_404);
@@ -332,6 +349,8 @@ pub struct StaticInfo {
     pub name: &'static str,
     /// The catcher's status code.
     pub code: Option<u16>,
+    /// The catcher's error type.
+    pub error_type: Option<(TypeId, &'static str)>,
     /// The catcher's handler, i.e, the annotated function.
     pub handler: for<'r> fn(Status, &'r Request<'_>, ErasedError<'r>) -> BoxFuture<'r>,
     /// The file, line, and column where the catcher was defined.
@@ -343,7 +362,13 @@ impl From<StaticInfo> for Catcher {
     #[inline]
     fn from(info: StaticInfo) -> Catcher {
         let mut catcher = Catcher::new(info.code, info.handler);
+        if info.error_type.is_some() {
+            // Lower rank if the error_type is defined, to ensure typed catchers
+            // are always tried first
+            catcher.rank -= 1;
+        }
         catcher.name = Some(info.name.into());
+        catcher.error_type = info.error_type;
         catcher.location = Some(info.location);
         catcher
     }
@@ -354,6 +379,7 @@ impl fmt::Debug for Catcher {
         f.debug_struct("Catcher")
             .field("name", &self.name)
             .field("base", &self.base)
+            .field("error_type", &self.error_type.as_ref().map(|(_, n)| n))
             .field("code", &self.code)
             .field("rank", &self.rank)
             .finish()

core/lib/src/catcher/handler.rs

@@ -31,7 +31,7 @@ pub type BoxFuture<'r, T = Result<'r>> = futures::future::BoxFuture<'r, T>;
 /// and used as follows:
 ///
 /// ```rust,no_run
-/// use rocket::{Request, Catcher, catcher::{self, ErasedErrorRef}};
+/// use rocket::{Request, Catcher, catcher::{self, ErasedError}};
 /// use rocket::response::{Response, Responder};
 /// use rocket::http::Status;
 ///
@@ -47,11 +47,13 @@ pub type BoxFuture<'r, T = Result<'r>> = futures::future::BoxFuture<'r, T>;
 ///
 /// #[rocket::async_trait]
 /// impl catcher::Handler for CustomHandler {
-///     async fn handle<'r>(&self, status: Status, req: &'r Request<'_>, _e: &ErasedErrorRef<'r>) -> catcher::Result<'r> {
+///     async fn handle<'r>(&self, status: Status, req: &'r Request<'_>, _e: ErasedError<'r>)
+///         -> catcher::Result<'r>
+///     {
 ///         let inner = match self.0 {
-///             Kind::Simple => "simple".respond_to(req)?,
-///             Kind::Intermediate => "intermediate".respond_to(req)?,
-///             Kind::Complex => "complex".respond_to(req)?,
+///             Kind::Simple => "simple".respond_to(req).map_err(|e| (e, _e))?,
+///             Kind::Intermediate => "intermediate".respond_to(req).map_err(|e| (e, _e))?,
+///             Kind::Complex => "complex".respond_to(req).map_err(|e| (e, _e))?,
 ///         };
 ///
 ///         Response::build_from(inner).status(status).ok()
@@ -99,7 +101,8 @@ pub trait Handler: Cloneable + Send + Sync + 'static {
     /// Nevertheless, failure is allowed, both for convenience and necessity. If
     /// an error handler fails, Rocket's default `500` catcher is invoked. If it
     /// succeeds, the returned `Response` is used to respond to the client.
-    async fn handle<'r>(&self, status: Status, req: &'r Request<'_>, error: ErasedError<'r>) -> Result<'r>;
+    async fn handle<'r>(&self, status: Status, req: &'r Request<'_>, error: ErasedError<'r>)
+        -> Result<'r>;
 }
 
 // We write this manually to avoid double-boxing.

core/lib/src/catcher/types.rs

@@ -1,6 +1,6 @@
 use transient::{Any, CanRecoverFrom, Co, Downcast};
 #[doc(inline)]
-pub use transient::{Static, Transient};
+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;

core/lib/src/error.rs

@@ -5,6 +5,7 @@ use std::error::Error as StdError;
 use std::sync::Arc;
 
 use figment::Profile;
+use transient::Static;
 
 use crate::listener::Endpoint;
 use crate::{Catcher, Ignite, Orbit, Phase, Rocket, Route};
@@ -85,10 +86,14 @@ pub enum ErrorKind {
     Shutdown(Arc<Rocket<Orbit>>),
 }
 
+impl Static for ErrorKind {}
+
 /// An error that occurs when a value was unexpectedly empty.
 #[derive(Clone, Copy, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Empty;
 
+impl Static for Empty {}
+
 impl Error {
     #[inline(always)]
     pub(crate) fn new(kind: ErrorKind) -> Error {