Remove explicit status from return code, instead relying on TypedError's status() method.

contrib/db_pools/codegen/src/database.rs

@@ -60,15 +60,16 @@ pub fn derive_database(input: TokenStream) -> TokenStream {
 
                     #[rocket::async_trait]
                     impl<'r> rocket::request::FromRequest<'r> for &'r #decorated_type {
-                        type Error = ();
+                        type Error = rocket::http::Status;
 
                         async fn from_request(
                             req: &'r rocket::request::Request<'_>
                         ) -> rocket::request::Outcome<Self, Self::Error> {
                             match #db_ty::fetch(req.rocket()) {
                                 Some(db) => rocket::outcome::Outcome::Success(db),
-                                None => rocket::outcome::Outcome::Error((
-                                    rocket::http::Status::InternalServerError, ()))
+                                None => rocket::outcome::Outcome::Error(
+                                    rocket::http::Status::InternalServerError
+                                )
                             }
                         }
                     }

contrib/db_pools/lib/src/database.rs

@@ -1,11 +1,11 @@
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 
+use rocket::TypedError;
 use rocket::{error, Build, Ignite, Phase, Rocket, Sentinel, Orbit};
 use rocket::fairing::{self, Fairing, Info, Kind};
 use rocket::request::{FromRequest, Outcome, Request};
 use rocket::figment::providers::Serialized;
-use rocket::http::Status;
 
 use crate::Pool;
 
@@ -278,17 +278,27 @@ impl<D: Database> Fairing for Initializer<D> {
     }
 }
 
+#[derive(Debug, TypedError)]
+pub enum ConnectionError<E> {
+    #[error(status = 503)]
+    ServiceUnavailable(E),
+    #[error(status = 500)]
+    InternalServerError,
+}
+
 #[rocket::async_trait]
-impl<'r, D: Database> FromRequest<'r> for Connection<D> {
-    type Error = Option<<D::Pool as Pool>::Error>;
+impl<'r, D: Database> FromRequest<'r> for Connection<D>
+    where <D::Pool as Pool>::Error: Send + Sync,
+{
+    type Error = ConnectionError<<D::Pool as Pool>::Error>;
 
     async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {
         match D::fetch(req.rocket()) {
             Some(db) => match db.get().await {
                 Ok(conn) => Outcome::Success(Connection(conn)),
-                Err(e) => Outcome::Error((Status::ServiceUnavailable, Some(e))),
+                Err(e) => Outcome::Error(ConnectionError::ServiceUnavailable(e)),
             },
-            None => Outcome::Error((Status::InternalServerError, None)),
+            None => Outcome::Error(ConnectionError::InternalServerError),
         }
     }
 }

contrib/db_pools/lib/src/diesel.rs

@@ -27,7 +27,7 @@
 //! # #[macro_use] extern crate rocket;
 //! # #[cfg(feature = "diesel_mysql")] {
 //! use rocket_db_pools::{Database, Connection};
-//! use rocket_db_pools::diesel::{QueryResult, MysqlPool, prelude::*};
+//! use rocket_db_pools::diesel::{QueryResult, DieselError, MysqlPool, prelude::*};
 //!
 //! #[derive(Database)]
 //! #[database("diesel_mysql")]
@@ -58,6 +58,11 @@
 //!
 //!     Ok(format!("{post_ids:?}"))
 //! }
+//!
+//! #[catch(500, error = "<e>")]
+//! fn catch_diesel_error(e: &DieselError) -> String {
+//!     format!("{e:?}")
+//! }
 //! # }
 //! ```
 
@@ -92,17 +97,40 @@ pub use diesel_async::AsyncMysqlConnection;
 #[cfg(feature = "diesel_postgres")]
 pub use diesel_async::AsyncPgConnection;
 
-/// Alias of a `Result` with an error type of [`Debug`] for a `diesel::Error`.
+use rocket::TypedError;
+
+/// Wrapper type for diesel errors
+#[derive(Debug, TypedError)]
+pub struct DieselError(diesel::result::Error);
+
+impl std::ops::Deref for DieselError {
+    type Target = diesel::result::Error;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<diesel::result::Error> for DieselError {
+    fn as_ref(&self) -> &diesel::result::Error {
+        &self.0
+    }
+}
+
+impl From<diesel::result::Error> for DieselError {
+    fn from(e: diesel::result::Error) -> Self {
+        Self(e)
+    }
+}
+
+/// Alias of a `Result` with an error type of `diesel::Error`.
 ///
 /// `QueryResult` is a [`Responder`](rocket::response::Responder) when `T` (the
 /// `Ok` value) is a `Responder`. By using this alias as a route handler's
 /// return type, the `?` operator can be applied to fallible `diesel` functions
 /// in the route handler while still providing a valid `Responder` return type.
 ///
-/// See the [module level docs](self#example) for a usage example.
-///
-/// [`Debug`]: rocket::response::Debug
-pub type QueryResult<T, E = rocket::response::Debug<diesel::result::Error>> = Result<T, E>;
+/// See module level docs for usage, and catching the error type.
+pub type QueryResult<T, E = DieselError> = Result<T, E>;
 
 /// Type alias for an `async` pool of MySQL connections for `async` [diesel].
 ///

contrib/dyn_templates/src/metadata.rs

@@ -152,9 +152,9 @@ impl Sentinel for Metadata<'_> {
 /// (`500`) is returned.
 #[rocket::async_trait]
 impl<'r> FromRequest<'r> for Metadata<'r> {
-    type Error = ();
+    type Error = Status;
 
-    async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, ()> {
+    async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
         request.rocket().state::<ContextManager>()
             .map(|cm| request::Outcome::Success(Metadata(cm)))
             .unwrap_or_else(|| {
@@ -163,7 +163,7 @@ impl<'r> FromRequest<'r> for Metadata<'r> {
                     To use templates, you must attach `Template::fairing()`."
                 );
 
-                request::Outcome::Error((Status::InternalServerError, ()))
+                request::Outcome::Error(Status::InternalServerError)
             })
     }
 }

contrib/dyn_templates/src/template.rs

@@ -265,19 +265,21 @@ impl Template {
 /// extension and a fixed-size body containing the rendered template. If
 /// rendering fails, an `Err` of `Status::InternalServerError` is returned.
 impl<'r> Responder<'r, 'static> for Template {
-    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
-        let ctxt = req.rocket()
-            .state::<ContextManager>()
-            .ok_or_else(|| {
-                error!(
-                    "uninitialized template context: missing `Template::fairing()`.\n\
-                    To use templates, you must attach `Template::fairing()`."
-                );
-
-                Status::InternalServerError
-            })?;
+    type Error = Status;
+    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static, Self::Error> {
+        if let Some(ctxt) = req.rocket().state::<ContextManager>() {
+            match self.finalize(&ctxt.context()) {
+                Ok(v) => v.respond_to(req).map_err(|e| match e {}),
+                Err(s) => Err(s),
+            }
+        } else {
+            error!(
+                "uninitialized template context: missing `Template::fairing()`.\n\
+                To use templates, you must attach `Template::fairing()`."
+            );
 
-        self.finalize(&ctxt.context())?.respond_to(req)
+            Err(Status::InternalServerError)
+        }
     }
 }
 

contrib/sync_db_pools/codegen/src/database.rs

@@ -112,11 +112,11 @@ pub fn database_attr(attr: TokenStream, input: TokenStream) -> Result<TokenStrea
 
         #[#rocket::async_trait]
         impl<'r> #rocket::request::FromRequest<'r> for #guard_type {
-            type Error = ();
+            type Error = #rocket::http::Status;
 
             async fn from_request(
                 __r: &'r #rocket::request::Request<'_>
-            ) -> #rocket::request::Outcome<Self, ()> {
+            ) -> #rocket::request::Outcome<Self, Self::Error> {
                 <#conn>::from_request(__r).await.map(Self)
             }
         }

contrib/sync_db_pools/lib/src/connection.rs

@@ -4,7 +4,6 @@ use std::marker::PhantomData;
 use rocket::{Phase, Rocket, Ignite, Sentinel};
 use rocket::fairing::{AdHoc, Fairing};
 use rocket::request::{Request, Outcome, FromRequest};
-use rocket::outcome::IntoOutcome;
 use rocket::http::Status;
 use rocket::trace::Trace;
 
@@ -212,17 +211,17 @@ impl<K, C: Poolable> Drop for ConnectionPool<K, C> {
 
 #[rocket::async_trait]
 impl<'r, K: 'static, C: Poolable> FromRequest<'r> for Connection<K, C> {
-    type Error = ();
+    type Error = Status;
 
     #[inline]
-    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, ()> {
+    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
         match request.rocket().state::<ConnectionPool<K, C>>() {
-            Some(c) => c.get().await.or_error((Status::ServiceUnavailable, ())),
+            Some(c) => c.get().await.ok_or(Status::ServiceUnavailable).into(),
             None => {
                 let conn = std::any::type_name::<K>();
                 error!("`{conn}::fairing()` is not attached\n\
                     the fairing must be attached to use `{conn} in routes.");
-                Outcome::Error((Status::InternalServerError, ()))
+                Outcome::Error(Status::InternalServerError)
             }
         }
     }

contrib/ws/src/websocket.rs

@@ -238,7 +238,8 @@ impl<'r> FromRequest<'r> for WebSocket {
 }
 
 impl<'r, 'o: 'r> Responder<'r, 'o> for Channel<'o> {
-    fn respond_to(self, _: &'r Request<'_>) -> response::Result<'o> {
+    type Error = std::convert::Infallible;
+    fn respond_to(self, _: &'r Request<'_>) -> response::Result<'o, Self::Error> {
         Response::build()
             .raw_header("Sec-Websocket-Version", "13")
             .raw_header("Sec-WebSocket-Accept", self.ws.key.clone())
@@ -250,7 +251,8 @@ impl<'r, 'o: 'r> Responder<'r, 'o> for Channel<'o> {
 impl<'r, 'o: 'r, S> Responder<'r, 'o> for MessageStream<'o, S>
     where S: futures::Stream<Item = Result<Message>> + Send + 'o
 {
-    fn respond_to(self, _: &'r Request<'_>) -> response::Result<'o> {
+    type Error = std::convert::Infallible;
+    fn respond_to(self, _: &'r Request<'_>) -> response::Result<'o, Self::Error> {
         Response::build()
             .raw_header("Sec-Websocket-Version", "13")
             .raw_header("Sec-WebSocket-Accept", self.ws.key.clone())

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

@@ -1,19 +1,64 @@
 mod parse;
 
-use devise::ext::SpanDiagnosticExt;
-use devise::{Spanned, Result};
+use devise::{Result, Spanned};
 use proc_macro2::{TokenStream, Span};
 
 use crate::http_codegen::Optional;
-use crate::syn_ext::ReturnTypeExt;
+use crate::syn_ext::{IdentExt, ReturnTypeExt};
 use crate::exports::*;
 
+use self::parse::ErrorGuard;
+
+use super::param::Guard;
+
+fn error_type(guard: &ErrorGuard) -> TokenStream {
+    let ty = &guard.ty;
+    quote! {
+        #_catcher::type_id_of::<#ty>()
+    }
+}
+
+fn error_guard_decl(guard: &ErrorGuard) -> TokenStream {
+    let (ident, ty) = (guard.ident.rocketized(), &guard.ty);
+    quote_spanned! { ty.span() =>
+        let #ident: &#ty = match #_catcher::downcast(__error_init) {
+            Some(v) => v,
+            None => return #_Result::Err(#__status),
+        };
+    }
+}
+
+fn request_guard_decl(guard: &Guard) -> TokenStream {
+    let (ident, ty) = (guard.fn_ident.rocketized(), &guard.ty);
+    quote_spanned! { ty.span() =>
+        let #ident: #ty = match <#ty as #FromError>::from_error(
+            #__status,
+            #__req,
+            __error_init
+        ).await {
+            #_Result::Ok(__v) => __v,
+            #_Result::Err(__e) => {
+                ::rocket::trace::info!(
+                    name: "forward",
+                    target: concat!("rocket::codegen::catch::", module_path!()),
+                    parameter = stringify!(#ident),
+                    type_name = stringify!(#ty),
+                    status = __e.code,
+                    "error guard forwarding; trying next catcher"
+                );
+
+                return #_Err(#__status);
+            },
+        };
+    }
+}
+
 pub fn _catch(
     args: proc_macro::TokenStream,
     input: proc_macro::TokenStream
 ) -> Result<TokenStream> {
     // Parse and validate all of the user's input.
-    let catch = parse::Attribute::parse(args.into(), input)?;
+    let catch = parse::Attribute::parse(args.into(), input.into())?;
 
     // Gather everything we'll need to generate the catcher.
     let user_catcher_fn = &catch.function;
@@ -22,35 +67,28 @@ pub fn _catch(
     let status_code = Optional(catch.status.map(|s| s.code));
     let deprecated = catch.function.attrs.iter().find(|a| a.path().is_ident("deprecated"));
 
-    // Determine the number of parameters that will be passed in.
-    if catch.function.sig.inputs.len() > 2 {
-        return Err(catch.function.sig.paren_token.span.join()
-            .error("invalid number of arguments: must be zero, one, or two")
-            .help("catchers optionally take `&Request` or `Status, &Request`"));
-    }
-
     // This ensures that "Responder not implemented" points to the return type.
     let return_type_span = catch.function.sig.output.ty()
         .map(|ty| ty.span())
         .unwrap_or_else(Span::call_site);
 
-    // Set the `req` and `status` spans to that of their respective function
-    // arguments for a more correct `wrong type` error span. `rev` to be cute.
-    let codegen_args = &[__req, __status];
-    let inputs = catch.function.sig.inputs.iter().rev()
-        .zip(codegen_args.iter())
-        .map(|(fn_arg, codegen_arg)| match fn_arg {
-            syn::FnArg::Receiver(_) => codegen_arg.respanned(fn_arg.span()),
-            syn::FnArg::Typed(a) => codegen_arg.respanned(a.ty.span())
-        }).rev();
+    let error_guard = catch.error_guard.as_ref().map(error_guard_decl);
+    let error_type = Optional(catch.error_guard.as_ref().map(error_type));
+    let request_guards = catch.request_guards.iter().map(request_guard_decl);
+    let parameter_names = catch.arguments.map.values()
+        .map(|(ident, _)| ident.rocketized());
 
     // We append `.await` to the function call if this is `async`.
     let dot_await = catch.function.sig.asyncness
         .map(|a| quote_spanned!(a.span() => .await));
 
     let catcher_response = quote_spanned!(return_type_span => {
-        let ___responder = #user_catcher_fn_name(#(#inputs),*) #dot_await;
-        #_response::Responder::respond_to(___responder, #__req)?
+        let ___responder = #user_catcher_fn_name(#(#parameter_names),*) #dot_await;
+        match #_response::Responder::respond_to(___responder, #__req) {
+            #_Ok(v) => v,
+            // If the responder fails, we drop any typed error, and convert to 500
+            #_Err(_) => return #_Err(#Status::InternalServerError),
+        }
     });
 
     // Generate the catcher, keeping the user's input around.
@@ -68,20 +106,26 @@ pub fn _catch(
             fn into_info(self) -> #_catcher::StaticInfo {
                 fn monomorphized_function<'__r>(
                     #__status: #Status,
-                    #__req: &'__r #Request<'_>
+                    #__req: &'__r #Request<'_>,
+                    __error_init: #_Option<&'__r (dyn #TypedError<'__r> + '__r)>,
                 ) -> #_catcher::BoxFuture<'__r> {
                     #_Box::pin(async move {
+                        #error_guard
+                        #(#request_guards)*
                         let __response = #catcher_response;
-                        #Response::build()
-                            .status(#__status)
-                            .merge(__response)
-                            .ok()
+                        #_Result::Ok(
+                            #Response::build()
+                                .status(#__status)
+                                .merge(__response)
+                                .finalize()
+                        )
                     })
                 }
 
                 #_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!()),
                 }