Updates to improve many aspects

Author: the10thWiz

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 = std::convert::Infallible;
+    fn respond_to(self, req: &'r Request<'_>) -> response::Outcome<'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),
+            }
+        } else {
+            error!(
+                "uninitialized template context: missing `Template::fairing()`.\n\
+                To use templates, you must attach `Template::fairing()`."
+            );
 
-        self.finalize(&ctxt.context())?.respond_to(req)
+            response::Outcome::Forward(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::Outcome<'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::Outcome<'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

@@ -21,9 +21,9 @@ fn error_type(guard: &ErrorGuard) -> TokenStream {
 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.as_ref()) {
+        let #ident: &#ty = match #_catcher::downcast(__error_init) {
             Some(v) => v,
-            None => return #_Result::Err((#__status, __error_init)),
+            None => return #_Result::Err(#__status),
         };
     }
 }
@@ -43,7 +43,7 @@ fn request_guard_decl(guard: &Guard) -> TokenStream {
                     "request guard forwarding; trying next catcher"
                 );
 
-                return #_Err((#__status, __error_init));
+                return #_Err(#__status);
             },
             #[allow(unreachable_code)]
             #Outcome::Error((__c, __e)) => {
@@ -56,7 +56,7 @@ fn request_guard_decl(guard: &Guard) -> TokenStream {
                     "request guard failed; forwarding to 500 handler"
                 );
 
-                return #_Err((#Status::InternalServerError, __error_init));
+                return #_Err(#Status::InternalServerError);
             }
         };
     }
@@ -97,7 +97,11 @@ pub fn _catch(
 
     let catcher_response = quote_spanned!(return_type_span => {
         let ___responder = #user_catcher_fn_name(#(#parameter_names),*) #dot_await;
-        #_response::Responder::respond_to(___responder, #__req).map_err(|s| (s, __error_init))?
+        match #_response::Responder::respond_to(___responder, #__req) {
+            #Outcome::Success(v) => v,
+            // If the responder fails, we drop any typed error, and convert to 500
+            #Outcome::Error(_) | #Outcome::Forward(_) => return Err(#Status::InternalServerError),
+        }
     });
 
     // Generate the catcher, keeping the user's input around.
@@ -116,7 +120,7 @@ pub fn _catch(
                 fn monomorphized_function<'__r>(
                     #__status: #Status,
                     #__req: &'__r #Request<'_>,
-                    __error_init: #ErasedError<'__r>,
+                    __error_init: #_Option<&'__r (dyn #TypedError<'__r> + '__r)>,
                 ) -> #_catcher::BoxFuture<'__r> {
                     #_Box::pin(async move {
                         #error_guard

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

@@ -113,16 +113,17 @@ fn query_decls(route: &Route) -> Option<TokenStream> {
                             "{_err}"
                         ); } }
                 );
+                let __e = #resolve_error!(__e);
                 ::rocket::trace::info!(
                     target: concat!("rocket::codegen::route::", module_path!()),
-                    error_type = ::std::any::type_name_of_val(&__e),
+                    error_type = __e.name(),
                     "Forwarding error"
                 );
 
                 return #Outcome::Forward((
                     #__data,
                     #Status::UnprocessableEntity,
-                    #resolve_error!(__e)
+                    __e.val
                 ));
             }
 
@@ -134,7 +135,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, resolve_error
+        __req, __data, _request, display_hack, FromRequest, Outcome, resolve_error, _None
     );
 
     quote_spanned! { ty.span() =>
@@ -150,21 +151,22 @@ fn request_guard_decl(guard: &Guard) -> TokenStream {
                     "request guard forwarding"
                 );
 
-                return #Outcome::Forward((#__data, __e, #resolve_error!()));
+                return #Outcome::Forward((#__data, __e, #_None));
             },
             #[allow(unreachable_code)]
             #Outcome::Error((__c, __e)) => {
+                let __err = #resolve_error!(__e);
                 ::rocket::trace::info!(
                     name: "failure",
                     target: concat!("rocket::codegen::route::", module_path!()),
                     parameter = stringify!(#ident),
                     type_name = stringify!(#ty),
-                    reason = %#display_hack!(&__e),
-                    error_type = ::std::any::type_name_of_val(&__e),
+                    // reason = %#display_hack!(&__e),
+                    error_type = __err.name,
                     "request guard failed"
                 );
 
-                return #Outcome::Error((__c, #resolve_error!(__e)));
+                return #Outcome::Error((__c, __err.val));
             }
         };
     }
@@ -179,17 +181,18 @@ fn param_guard_decl(guard: &Guard) -> TokenStream {
 
     // Returned when a dynamic parameter fails to parse.
     let parse_error = quote!({
+        let __err = #resolve_error!(__error);
         ::rocket::trace::info!(
             name: "forward",
             target: concat!("rocket::codegen::route::", module_path!()),
             parameter = #name,
             type_name = stringify!(#ty),
-            reason = %#display_hack!(&__error),
-            error_type = ::std::any::type_name_of_val(&__error),
+            // reason = %#display_hack!(&__error),
+            error_type = __err.name,
             "path guard forwarding"
         );
 
-        #Outcome::Forward((#__data, #Status::UnprocessableEntity, #resolve_error!(__error)))
+        #Outcome::Forward((#__data, #Status::UnprocessableEntity, __err.val))
     });
 
     // All dynamic parameters should be found if this function is being called;
@@ -214,7 +217,7 @@ fn param_guard_decl(guard: &Guard) -> TokenStream {
                     return #Outcome::Forward((
                         #__data,
                         #Status::InternalServerError,
-                        #resolve_error!()
+                        #_None
                     ));
                 }
             }
@@ -235,7 +238,7 @@ 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);
+        __req, __data, display_hack, FromData, Outcome, resolve_error, _None);
 
     quote_spanned! { ty.span() =>
         let #ident: #ty = match <#ty as #FromData>::from_data(#__req, #__data).await {
@@ -250,21 +253,22 @@ fn data_guard_decl(guard: &Guard) -> TokenStream {
                     "data guard forwarding"
                 );
 
-                return #Outcome::Forward((__d, __e, #resolve_error!()));
+                return #Outcome::Forward((__d, __e, #_None));
             }
             #[allow(unreachable_code)]
             #Outcome::Error((__c, __e)) => {
+                let __e = #resolve_error!(__e);
                 ::rocket::trace::info!(
                     name: "failure",
                     target: concat!("rocket::codegen::route::", module_path!()),
                     parameter = stringify!(#ident),
                     type_name = stringify!(#ty),
-                    reason = %#display_hack!(&__e),
-                    error_type = ::std::any::type_name_of_val(&__e),
+                    // reason = %#display_hack!(&__e),
+                    error_type = __e.name,
                     "data guard failed"
                 );
 
-                return #Outcome::Error((__c, #resolve_error!(__e)));
+                return #Outcome::Error((__c, __e.val));
             }
         };
     }

core/codegen/src/exports.rs

@@ -86,6 +86,7 @@ define_exported_paths! {
     _Vec => ::std::vec::Vec,
     _Cow => ::std::borrow::Cow,
     _ExitCode => ::std::process::ExitCode,
+    _trace => ::rocket::trace,
     display_hack => ::rocket::error::display_hack,
     BorrowMut => ::std::borrow::BorrowMut,
     Outcome => ::rocket::outcome::Outcome,
@@ -103,7 +104,7 @@ define_exported_paths! {
     Catcher => ::rocket::Catcher,
     Status => ::rocket::http::Status,
     resolve_error => ::rocket::catcher::resolve_typed_catcher,
-    ErasedError => ::rocket::catcher::ErasedError,
+    TypedError => ::rocket::catcher::TypedError,
 }
 
 macro_rules! define_spanned_export {

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.4" }
+transient = { version = "0.4", path = "/home/matthew/transient" }
 
 [dependencies.serde]
 version = "1.0"

core/lib/Cargo.toml

@@ -27,8 +27,8 @@ default = ["http2", "tokio-macros", "trace"]
 http2 = ["hyper/http2", "hyper-util/http2"]
 http3-preview = ["s2n-quic", "s2n-quic-h3", "tls"]
 secrets = ["cookie/private", "cookie/key-expansion"]
-json = ["serde_json"]
-msgpack = ["rmp-serde"]
+json = ["serde_json", "transient/serde_json"]
+msgpack = ["rmp-serde", "transient/rmp-serde"]
 uuid = ["uuid_", "rocket_http/uuid", "transient/uuid"]
 tls = ["rustls", "tokio-rustls", "rustls-pemfile"]
 mtls = ["tls", "x509-parser"]
@@ -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.4" }
+transient = { version = "0.4", features = ["either"], path = "/home/matthew/transient" }
 
 # tracing
 tracing = { version = "0.1.40", default-features = false, features = ["std", "attributes"] }

core/lib/src/catcher/catcher.rs

@@ -8,9 +8,7 @@ use crate::http::ext::IntoOwned;
 use crate::response::Response;
 use crate::request::Request;
 use crate::http::{Status, ContentType, uri};
-use crate::catcher::{Handler, BoxFuture};
-
-use super::ErasedError;
+use crate::catcher::{BoxFuture, TypedError, Handler};
 
 /// An error catching route.
 ///
@@ -324,7 +322,7 @@ impl Catcher {
 
 impl Default for Catcher {
     fn default() -> Self {
-        fn handler<'r>(s: Status, req: &'r Request<'_>, _e: ErasedError<'r>) -> BoxFuture<'r> {
+        fn handler<'r>(s: Status, req: &'r Request<'_>, _e: Option<&(dyn TypedError<'r> + 'r)>) -> BoxFuture<'r> {
             Box::pin(async move { Ok(default_handler(s, req)) })
         }
 
@@ -344,7 +342,7 @@ pub struct StaticInfo {
     /// 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>,
+    pub handler: for<'r> fn(Status, &'r Request<'_>, Option<&'r (dyn TypedError<'r> + 'r)>) -> BoxFuture<'r>,
     /// The file, line, and column where the catcher was defined.
     pub location: (&'static str, u32, u32),
 }

core/lib/src/catcher/handler.rs

@@ -1,11 +1,10 @@
 use crate::{Request, Response};
+use crate::catcher::TypedError;
 use crate::http::Status;
 
-use super::ErasedError;
-
 /// Type alias for the return type of a [`Catcher`](crate::Catcher)'s
 /// [`Handler::handle()`].
-pub type Result<'r> = std::result::Result<Response<'r>, (crate::http::Status, ErasedError<'r>)>;
+pub type Result<'r> = std::result::Result<Response<'r>, crate::http::Status>;
 
 /// Type alias for the return type of a _raw_ [`Catcher`](crate::Catcher)'s
 /// [`Handler`].
@@ -101,19 +100,19 @@ 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>)
+    async fn handle<'r>(&self, status: Status, req: &'r Request<'_>, error: Option<&'r (dyn TypedError<'r> + 'r)>)
         -> Result<'r>;
 }
 
 // We write this manually to avoid double-boxing.
 impl<F: Clone + Sync + Send + 'static> Handler for F
-    where for<'x> F: Fn(Status, &'x Request<'_>, ErasedError<'x>) -> BoxFuture<'x>,
+    where for<'x> F: Fn(Status, &'x Request<'_>, Option<&'x (dyn TypedError<'x> + 'x)>) -> BoxFuture<'x>,
 {
-    fn handle<'r, 'life0, 'life1, 'async_trait>(
+    fn handle<'r, 'life0, 'life1, 'life2, 'async_trait>(
         &'life0 self,
         status: Status,
         req: &'r Request<'life1>,
-        error: ErasedError<'r>,
+        error: Option<&'r (dyn TypedError<'r> + 'r)>,
     ) -> BoxFuture<'r>
         where 'r: 'async_trait,
               'life0: 'async_trait,
@@ -126,7 +125,7 @@ impl<F: Clone + Sync + Send + 'static> Handler for F
 
 // Used in tests! Do not use, please.
 #[doc(hidden)]
-pub fn dummy_handler<'r>(_: Status, _: &'r Request<'_>, _: ErasedError<'r>) -> BoxFuture<'r> {
+pub fn dummy_handler<'r>(_: Status, _: &'r Request<'_>, _: Option<&(dyn TypedError<'r> + 'r)>) -> BoxFuture<'r> {
    Box::pin(async move { Ok(Response::new()) })
 }