Remove explicit status parameter in most cases

Author: the10thWiz

contrib/db_pools/lib/src/database.rs

@@ -287,7 +287,9 @@ pub enum ConnectionError<E> {
 }
 
 #[rocket::async_trait]
-impl<'r, D: Database> FromRequest<'r> for Connection<D> {
+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> {

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:?}")
+//! }
 //! # }
 //! ```
 
@@ -117,17 +122,14 @@ impl From<diesel::result::Error> for DieselError {
     }
 }
 
-/// Alias of a `Result` with an error type of [`Debug`] for a `diesel::Error`.
+/// 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
-// TODO: this needs to change
+/// 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/template.rs

@@ -265,21 +265,20 @@ 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 {
-    // TODO: typed: This should be a more useful type
-    type Error = std::convert::Infallible;
-    fn respond_to(self, req: &'r Request<'_>) -> response::Outcome<'static, Self::Error> {
+    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),
-                Err(s) => response::Outcome::Forward(s),
+                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()`."
             );
 
-            response::Outcome::Forward(Status::InternalServerError)
+            Err(Status::InternalServerError)
         }
     }
 }

contrib/ws/src/websocket.rs

@@ -239,7 +239,7 @@ impl<'r> FromRequest<'r> for WebSocket {
 
 impl<'r, 'o: 'r> Responder<'r, 'o> for Channel<'o> {
     type Error = std::convert::Infallible;
-    fn respond_to(self, _: &'r Request<'_>) -> response::Outcome<'o, Self::Error> {
+    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())
@@ -252,7 +252,7 @@ impl<'r, 'o: 'r, S> Responder<'r, 'o> for MessageStream<'o, S>
     where S: futures::Stream<Item = Result<Message>> + Send + 'o
 {
     type Error = std::convert::Infallible;
-    fn respond_to(self, _: &'r Request<'_>) -> response::Outcome<'o, Self::Error> {
+    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

@@ -85,9 +85,9 @@ pub fn _catch(
     let catcher_response = quote_spanned!(return_type_span => {
         let ___responder = #user_catcher_fn_name(#(#parameter_names),*) #dot_await;
         match #_response::Responder::respond_to(___responder, #__req) {
-            #Outcome::Success(v) => v,
+            #_Ok(v) => v,
             // If the responder fails, we drop any typed error, and convert to 500
-            #Outcome::Error(_) | #Outcome::Forward(_) => return Err(#Status::InternalServerError),
+            #_Err(_) => return #_Err(#Status::InternalServerError),
         }
     });
 

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

@@ -136,7 +136,7 @@ fn query_decls(route: &Route) -> Option<TokenStream> {
 fn request_guard_decl(guard: &Guard) -> TokenStream {
     let (ident, ty) = (guard.fn_ident.rocketized(), &guard.ty);
     define_spanned_export!(ty.span() =>
-        __req, __data, _request, display_hack, FromRequest, Outcome, TypedError, resolve_error, _Box, Status
+        __req, __data, _request, display_hack, FromRequest, Outcome, TypedError, _Box
     );
 
     quote_spanned! { ty.span() =>
@@ -156,26 +156,23 @@ fn request_guard_decl(guard: &Guard) -> TokenStream {
             },
             #[allow(unreachable_code)]
             #Outcome::Error(__e) => {
-                let __err = #resolve_error!(__e);
-                let __err_ptr = match &__err.val {
-                    Err(r) => &r.0,
+                let __err: #_Box<dyn #TypedError<'__r>> = #_Box::new(__e);
                     // SAFETY: This is a pointer to __e (after moving it into a box),
                     // so it's safe to cast it to the same type. If #ty implements
                     // TypedError, we could downcast, but we can't write that if it doesn't.
-                    Ok(b) => unsafe { &*(b.as_ref() as *const dyn #TypedError<'_>).cast() },
-                };
+                let __err_ptr: &<#ty as #FromRequest<'__r>>::Error
+                    = unsafe { &*(__err.as_ref() as *const dyn #TypedError<'_>).cast() };
                 ::rocket::trace::info!(
                     name: "failure",
                     target: concat!("rocket::codegen::route::", module_path!()),
                     parameter = stringify!(#ident),
                     type_name = stringify!(#ty),
                     reason = %#display_hack!(__err_ptr),
-                    error_type = __err.name,
+                    error_type = __err.name(),
                     "request guard failed"
                 );
 
-                // TODO: Default status
-                return #Outcome::Error(__err.val.unwrap_or_else(|_| #_Box::new(#Status::InternalServerError)));
+                return #Outcome::Error(__err);
             }
         };
     }
@@ -298,7 +295,6 @@ fn data_guard_decl(guard: &Guard) -> TokenStream {
                     "data guard failed"
                 );
 
-                // TODO: default status
                 return #Outcome::Error(__e.val.unwrap_or_else(|_| #_Box::new(#Status::UnprocessableEntity)));
             }
         };

core/codegen/src/derive/responder.rs

@@ -77,7 +77,7 @@ pub fn derive_responder(input: proc_macro::TokenStream) -> TokenStream {
         .inner_mapper(MapperBuild::new()
             .with_output(|_, output| quote! {
                 fn respond_to(self, __req: &'r #Request<'_>)
-                    -> #_response::Outcome<'o, Self::Error>
+                    -> #_response::Result<'o, Self::Error>
                 {
                     #output
                 }
@@ -106,9 +106,9 @@ pub fn derive_responder(input: proc_macro::TokenStream) -> TokenStream {
                         let mut __res = match <#ty as #_response::Responder>::respond_to(
                             #accessor, __req
                         ) {
-                            #Outcome::Success(val) => val,
-                            #Outcome::Error(e) => return #Outcome::Error(#error_outcome),
-                            #Outcome::Forward(f) => return #Outcome::Forward(f),
+                            #_Result::Ok(val) => val,
+                            #_Result::Err(e) => return #_Result::Err(#error_outcome),
+                            // #Outcome::Forward(f) => return #Outcome::Forward(f),
                         };
                     }
                 }).expect("have at least one field");
@@ -133,7 +133,7 @@ pub fn derive_responder(input: proc_macro::TokenStream) -> TokenStream {
                     #(#headers)*
                     #content_type
                     #status
-                    #Outcome::Success(__res)
+                    #_Ok(__res)
                 })
             })
         )
@@ -205,6 +205,10 @@ pub fn derive_responder(input: proc_macro::TokenStream) -> TokenStream {
                         #i: #_catcher::Transient,
                         <#i as #_catcher::Transient>::Transience: #_catcher::CanTranscendTo<#_catcher::Inv<'r>>,
                     });
+                let debug_bounds = type_params.iter()
+                    .map(|i| quote! {
+                        #i: ::std::fmt::Debug,
+                    });
                 quote!{
                     pub enum #name<'r, #(#type_params,)*> {
                         #(#variants_decl)*
@@ -230,6 +234,18 @@ pub fn derive_responder(input: proc_macro::TokenStream) -> TokenStream {
                         type Transience = ::rocket::catcher::Inv<'r>;
                     }
 
+                    impl<'r, #(#type_params,)*> ::std::fmt::Debug
+                        for #name<'r, #(#type_params,)*>
+                            where #(#debug_bounds)*
+                    {
+                        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                            match self {
+                                #(Self::#type_params(v) => v.fmt(f),)*
+                                Self::UnusedVariant(f, ..) => match *f { }
+                            }
+                        }
+                    }
+
                     impl<'r, #(#type_params,)*> #TypedError<'r>
                         for #name<'r, #(#type_params,)*>
                             where #(#error_bounds)*

core/codegen/src/lib.rs

@@ -320,10 +320,9 @@ route_attribute!(options => Method::Options);
 /// SINGLE_PARAM := '<' IDENT '>'
 /// ```
 ///
-/// TODO: typed: docs (links)
 /// # Typing Requirements
 ///
-/// The type of the `error` arguement must be a reference to a type that implements `TypedError`. See
+/// The type of the `error` arguement must be a reference to a type that implements [`TypedError`]. See
 /// [Typed catchers](Self#Typed-catchers) for more info.
 ///
 /// All other arguments must implement [`FromError`], (or [`FromRequest`]).
@@ -336,26 +335,24 @@ route_attribute!(options => Method::Options);
 /// error types. This is accomplished using the [`TypedError`] trait.
 /// When a [`FromRequest`], [`FromParam`],
 /// [`FromSegments`], [`FromForm`], or [`FromData`] implementation fails or
-/// forwards, Rocket will convert to the error type to `dyn TypedError`, if the
-/// error type implements `TypedError`.
+/// forwards, Rocket will convert to the error type to [`dyn TypedError`], if the
+/// error type implements [`TypedError`].
 ///
 /// Only a single error type can be carried by a request - if a route forwards,
 /// and another route is attempted, any error produced by the second route
 /// overwrites the first.
 ///
 /// There are two convient types - [`FromParam`] types actually generate a
 /// [`FromParamError<T>`] (although you can still catch the inner `T` type).
-/// Likewise [`FromSegements`] actually generates [`FromSegementsError<T>`].
+/// Likewise [`FromSegments`] actually generates [`FromSegmentsError<T>`].
 ///
 /// ## Custom error types
 ///
-/// All[^transient-impls] error types that Rocket itself produces implement
+/// All error types that Rocket itself produces implement
 /// [`TypedError`], and can therefore be caught by a typed catcher. If you have
 /// a custom guard of any type, you can implement [`TypedError`] using the derive
 /// macro.
 ///
-/// [^transient-impls]: As of writing, this is a WIP.
-///
 /// # Semantics
 ///
 /// The attribute generates two items:
@@ -382,7 +379,15 @@ route_attribute!(options => Method::Options);
 /// [`Catcher`]: ../rocket/struct.Catcher.html
 /// [`Response`]: ../rocket/struct.Response.html
 /// [`Responder`]: ../rocket/response/trait.Responder.html
+/// [`FromError`]: ../rocket/catcher/trait.FromError.html
 /// [`FromRequest`]: ../rocket/request/trait.FromRequest.html
+/// [`FromParam`]: ../rocket/request/trait.FromParam.html
+/// [`FromSegments`]: ../rocket/request/trait.FromSegments.html
+/// [`FromData`]: ../rocket/data/trait.FromData.html
+/// [`TypedError`]: ../rocket/catcher/trait.TypedError.html
+/// [`dyn TypedError`]: ../rocket/catcher/trait.TypedError.html
+/// [`FromParamError<T>`]: ../rocket/request/struct.FromParamError.html
+/// [`FromSegmentsError<T>`]: ../rocket/request/struct.FromSegmentsError.html
 #[proc_macro_attribute]
 pub fn catch(args: TokenStream, input: TokenStream) -> TokenStream {
     emit!(attribute::catch::catch_attribute(args, input))
@@ -470,7 +475,7 @@ pub fn async_test(args: TokenStream, input: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
-/// For all other cases, use [`#[launch]`](launch) instead.
+/// For all other cases, use [`#[launch]`](macro@launch) instead.
 ///
 /// The function attributed with `#[rocket::main]` _must_ be `async` and _must_
 /// be called `main`. Violation of either results in a compile-time error.

core/http/src/status.rs

@@ -1,4 +1,4 @@
-use std::fmt;
+use std::{convert::Infallible, fmt};
 
 use transient::Static;
 
@@ -128,6 +128,12 @@ impl Default for Status {
     }
 }
 
+impl From<Infallible> for Status {
+    fn from(v: Infallible) -> Self {
+        match v {}
+    }
+}
+
 macro_rules! ctrs {
     ($($code:expr, $code_str:expr, $name:ident => $reason:expr),+) => {
         $(

core/lib/src/catcher/catcher.rs

@@ -153,18 +153,18 @@ impl Catcher {
     ///    -> BoxFuture<'r>
     /// {
     ///    let res = (status, format!("404: {}", req.uri()));
-    ///    Box::pin(async move { res.respond_to(req).responder_error() })
+    ///    Box::pin(async move { res.respond_to(req).map_err(|e| e.into()) })
     /// }
     ///
     /// fn handle_500<'r>(_: Status, req: &'r Request<'_>, _e: Option<&'r dyn TypedError<'r>>) -> BoxFuture<'r> {
-    ///     Box::pin(async move{ "Whoops, we messed up!".respond_to(req).responder_error() })
+    ///     Box::pin(async move{ "Whoops, we messed up!".respond_to(req).map_err(|e| e.into()) })
     /// }
     ///
     /// fn handle_default<'r>(status: Status, req: &'r Request<'_>, _e: Option<&'r dyn TypedError<'r>>)
     ///    -> BoxFuture<'r>
     /// {
     ///    let res = (status, format!("{}: {}", status, req.uri()));
-    ///    Box::pin(async move { res.respond_to(req).responder_error() })
+    ///    Box::pin(async move { res.respond_to(req).map_err(|e| e.into()) })
     /// }
     ///
     /// let not_found_catcher = Catcher::new(404, handle_404);
@@ -210,7 +210,7 @@ impl Catcher {
     ///    -> BoxFuture<'r>
     /// {
     ///    let res = (status, format!("404: {}", req.uri()));
-    ///    Box::pin(async move { res.respond_to(req).responder_error() })
+    ///    Box::pin(async move { res.respond_to(req).map_err(|e| e.into()) })
     /// }
     ///
     /// let catcher = Catcher::new(404, handle_404);
@@ -239,7 +239,7 @@ impl Catcher {
     ///    -> BoxFuture<'r>
     /// {
     ///    let res = (status, format!("404: {}", req.uri()));
-    ///    Box::pin(async move { res.respond_to(req).responder_error() })
+    ///    Box::pin(async move { res.respond_to(req).map_err(|e| e.into()) })
     /// }
     ///
     /// let catcher = Catcher::new(404, handle_404);
@@ -294,7 +294,7 @@ impl Catcher {
     ///    -> BoxFuture<'r>
     /// {
     ///    let res = (status, format!("404: {}", req.uri()));
-    ///    Box::pin(async move { res.respond_to(req).responder_error() })
+    ///    Box::pin(async move { res.respond_to(req).map_err(|e| e.into()) })
     /// }
     ///
     /// let catcher = Catcher::new(404, handle_404);