Working example

Author: the10thWiz

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

@@ -23,7 +23,7 @@ pub fn _catch(
     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 {
+    if catch.function.sig.inputs.len() > 3 {
         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`"));
@@ -36,7 +36,6 @@ pub fn _catch(
 
     // TODO: how to handle request?
     //   - Right now: (), (&Req), (Status, &Req) allowed
-    //   - New: (), (&E), (&Req, &E), (Status, &Req, &E)
     // 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, __error];
@@ -46,9 +45,13 @@ 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 let Some(arg) = catch.function.sig.inputs.iter().rev().next() {
+    let make_error = if catch.function.sig.inputs.len() >= 3 {
+        let arg = catch.function.sig.inputs.first().unwrap();
         quote_spanned!(arg.span() => 
-            // let 
+            let #__error = match ::rocket::catcher::downcast(__error_init.as_ref()) {
+                Some(v) => v,
+                None => return #_Result::Err((#__status, __error_init)),
+            };
         )
     } else {
         quote! {}
@@ -60,7 +63,7 @@ pub fn _catch(
 
     let catcher_response = quote_spanned!(return_type_span => {
         let ___responder = #user_catcher_fn_name(#(#inputs),*) #dot_await;
-        #_response::Responder::respond_to(___responder, #__req)?
+        #_response::Responder::respond_to(___responder, #__req).map_err(|s| (s, __error_init))?
     });
 
     // Generate the catcher, keeping the user's input around.
@@ -79,15 +82,17 @@ pub fn _catch(
                 fn monomorphized_function<'__r>(
                     #__status: #Status,
                     #__req: &'__r #Request<'_>,
-                    __error_init: &#ErasedErrorRef<'__r>,
+                    __error_init: #ErasedError<'__r>,
                 ) -> #_catcher::BoxFuture<'__r> {
                     #_Box::pin(async move {
                         #make_error
                         let __response = #catcher_response;
-                        #Response::build()
-                            .status(#__status)
-                            .merge(__response)
-                            .ok()
+                        #_Result::Ok(
+                            #Response::build()
+                                .status(#__status)
+                                .merge(__response)
+                                .finalize()
+                        )
                     })
                 }
 

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

@@ -1,7 +1,8 @@
 use devise::ext::SpanDiagnosticExt;
-use devise::{MetaItem, Spanned, Result, FromMeta, Diagnostic};
+use devise::{Diagnostic, FromMeta, MetaItem, Result, SpanWrapped, Spanned};
 use proc_macro2::TokenStream;
 
+use crate::attribute::param::Dynamic;
 use crate::{http, http_codegen};
 
 /// This structure represents the parsed `catch` attribute and associated items.
@@ -10,13 +11,15 @@ pub struct Attribute {
     pub status: Option<http::Status>,
     /// The function that was decorated with the `catch` attribute.
     pub function: syn::ItemFn,
+    pub error: Option<SpanWrapped<Dynamic>>,
 }
 
 /// We generate a full parser for the meta-item for great error messages.
 #[derive(FromMeta)]
 struct Meta {
     #[meta(naked)]
     code: Code,
+    // error: Option<SpanWrapped<Dynamic>>,
 }
 
 /// `Some` if there's a code, `None` if it's `default`.
@@ -49,10 +52,10 @@ impl Attribute {
 
         let attr: MetaItem = syn::parse2(quote!(catch(#args)))?;
         let status = Meta::from_meta(&attr)
-            .map(|meta| meta.code.0)
+            .map(|meta| meta)
             .map_err(|diag| diag.help("`#[catch]` expects a status code int or `default`: \
                         `#[catch(404)]` or `#[catch(default)]`"))?;
 
-        Ok(Attribute { status, function })
+        Ok(Attribute { status: status.code.0, function, error: status.error })
     }
 }

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

@@ -41,7 +41,7 @@ fn query_decls(route: &Route) -> Option<TokenStream> {
     }
 
     define_spanned_export!(Span::call_site() =>
-        __req, __data, _form, Outcome, _Ok, _Err, _Some, _None, Status
+        __req, __data, _form, Outcome, _Ok, _Err, _Some, _None, Status, resolve_error
     );
 
     // Record all of the static parameters for later filtering.
@@ -108,13 +108,13 @@ fn query_decls(route: &Route) -> Option<TokenStream> {
                 ::rocket::trace::span_info!(
                     "codegen",
                     "query string failed to match route declaration" =>
-                        { for _err in __e { ::rocket::trace::info!(
+                        { for _err in __e.iter() { ::rocket::trace::info!(
                             target: concat!("rocket::codegen::route::", module_path!()),
                             "{_err}"
                         ); } }
                 );
 
-                return #Outcome::Forward((#__data, #Status::UnprocessableEntity));
+                return #Outcome::Forward((#__data, #Status::UnprocessableEntity, #resolve_error!(__e)));
             }
 
             (#(#ident.unwrap()),*)
@@ -125,7 +125,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, ErrorResolver, ErrorDefault
+        __req, __data, _request, display_hack, FromRequest, Outcome, resolve_error
     );
 
     quote_spanned! { ty.span() =>
@@ -141,7 +141,7 @@ fn request_guard_decl(guard: &Guard) -> TokenStream {
                     "request guard forwarding"
                 );
 
-                return #Outcome::Forward((#__data, __e));
+                return #Outcome::Forward((#__data, __e, #resolve_error!()));
             },
             #[allow(unreachable_code)]
             #Outcome::Error((__c, __e)) => {
@@ -154,9 +154,7 @@ fn request_guard_decl(guard: &Guard) -> TokenStream {
                     "request guard failed"
                 );
 
-                #[allow(unused)]
-                use #ErrorDefault;
-                return #Outcome::Error((__c, #ErrorResolver::new(__e).cast()));
+                return #Outcome::Error((__c, #resolve_error!(__e)));
             }
         };
     }
@@ -166,7 +164,7 @@ fn param_guard_decl(guard: &Guard) -> TokenStream {
     let (i, name, ty) = (guard.index, &guard.name, &guard.ty);
     define_spanned_export!(ty.span() =>
         __req, __data, _None, _Some, _Ok, _Err,
-        Outcome, FromSegments, FromParam, Status, display_hack
+        Outcome, FromSegments, FromParam, Status, display_hack, resolve_error
     );
 
     // Returned when a dynamic parameter fails to parse.
@@ -176,11 +174,12 @@ fn param_guard_decl(guard: &Guard) -> TokenStream {
             target: concat!("rocket::codegen::route::", module_path!()),
             parameter = #name,
             type_name = stringify!(#ty),
-            reason = %#display_hack!(__error),
+            error_ty = std::any::type_name_of_val(&__error),
+            reason = %#display_hack!(&__error),
             "path guard forwarding"
         );
 
-        #Outcome::Forward((#__data, #Status::UnprocessableEntity))
+        #Outcome::Forward((#__data, #Status::UnprocessableEntity, #resolve_error!(__error)))
     });
 
     // All dynamic parameters should be found if this function is being called;
@@ -202,7 +201,7 @@ fn param_guard_decl(guard: &Guard) -> TokenStream {
                         #i
                     );
 
-                    return #Outcome::Forward((#__data, #Status::InternalServerError));
+                    return #Outcome::Forward((#__data, #Status::InternalServerError, #resolve_error!()));
                 }
             }
         },
@@ -221,7 +220,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, ErrorResolver, ErrorDefault);
+    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 {
@@ -236,7 +235,7 @@ fn data_guard_decl(guard: &Guard) -> TokenStream {
                     "data guard forwarding"
                 );
 
-                return #Outcome::Forward((__d, __e));
+                return #Outcome::Forward((__d, __e, #resolve_error!()));
             }
             #[allow(unreachable_code)]
             #Outcome::Error((__c, __e)) => {
@@ -249,9 +248,7 @@ fn data_guard_decl(guard: &Guard) -> TokenStream {
                     "data guard failed"
                 );
 
-                #[allow(unused)]
-                use #ErrorDefault;
-                return #Outcome::Error((__c, #ErrorResolver::new(__e).cast()));
+                return #Outcome::Error((__c, #resolve_error!(__e)));
             }
         };
     }

core/codegen/src/exports.rs

@@ -102,9 +102,8 @@ define_exported_paths! {
     Route => ::rocket::Route,
     Catcher => ::rocket::Catcher,
     Status => ::rocket::http::Status,
-    ErrorResolver => ::rocket::catcher::resolution::Resolve,
-    ErrorDefault => ::rocket::catcher::resolution::DefaultTypeErase,
-    ErasedErrorRef => ::rocket::catcher::ErasedErrorRef,
+    resolve_error => ::rocket::catcher::resolve_typed_catcher,
+    ErasedError => ::rocket::catcher::ErasedError,
 }
 
 macro_rules! define_spanned_export {

core/http/Cargo.toml

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

core/http/src/uri/error.rs

@@ -1,6 +1,7 @@
 //! Errors arising from parsing invalid URIs.
 
 use std::fmt;
+use transient::Static;
 
 pub use crate::parse::uri::Error;
 
@@ -29,6 +30,8 @@ pub enum PathError {
     BadEnd(char),
 }
 
+impl Static for PathError {}
+
 impl fmt::Display for PathError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

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.0", path = "../../../transient" }
+transient = { version = "0.2.1" }
 
 # tracing
 tracing = { version = "0.1.40", default-features = false, features = ["std", "attributes"] }

core/lib/src/catcher/catcher.rs

@@ -8,7 +8,7 @@ use crate::request::Request;
 use crate::http::{Status, ContentType, uri};
 use crate::catcher::{Handler, BoxFuture};
 
-use super::ErasedErrorRef;
+use super::ErasedError;
 
 /// An error catching route.
 ///
@@ -315,7 +315,7 @@ impl Catcher {
 
 impl Default for Catcher {
     fn default() -> Self {
-        fn handler<'r>(s: Status, req: &'r Request<'_>, _e: &ErasedErrorRef<'r>) -> BoxFuture<'r> {
+        fn handler<'r>(s: Status, req: &'r Request<'_>, _e: ErasedError<'r>) -> BoxFuture<'r> {
             Box::pin(async move { Ok(default_handler(s, req)) })
         }
 
@@ -333,7 +333,7 @@ pub struct StaticInfo {
     /// The catcher's status code.
     pub code: Option<u16>,
     /// The catcher's handler, i.e, the annotated function.
-    pub handler: for<'r> fn(Status, &'r Request<'_>, &ErasedErrorRef<'r>) -> BoxFuture<'r>,
+    pub handler: for<'r> fn(Status, &'r Request<'_>, ErasedError<'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,11 @@
 use crate::{Request, Response};
 use crate::http::Status;
 
-use super::ErasedErrorRef;
+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>;
+pub type Result<'r> = std::result::Result<Response<'r>, (crate::http::Status, ErasedError<'r>)>;
 
 /// Type alias for the return type of a _raw_ [`Catcher`](crate::Catcher)'s
 /// [`Handler`].
@@ -99,23 +99,22 @@ 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: &ErasedErrorRef<'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.
 impl<F: Clone + Sync + Send + 'static> Handler for F
-    where for<'x> F: Fn(Status, &'x Request<'_>, &ErasedErrorRef<'x>) -> BoxFuture<'x>,
+    where for<'x> F: Fn(Status, &'x Request<'_>, ErasedError<'x>) -> BoxFuture<'x>,
 {
-    fn handle<'r, 'life0, 'life1, 'life2, 'async_trait>(
+    fn handle<'r, 'life0, 'life1, 'async_trait>(
         &'life0 self,
         status: Status,
         req: &'r Request<'life1>,
-        error: &'life2 ErasedErrorRef<'r>,
+        error: ErasedError<'r>,
     ) -> BoxFuture<'r>
         where 'r: 'async_trait,
               'life0: 'async_trait,
               'life1: 'async_trait,
-              'life2: 'async_trait,
               Self: 'async_trait,
     {
         self(status, req, error)
@@ -124,7 +123,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<'_>, _: &ErasedErrorRef<'r>) -> BoxFuture<'r> {
+pub fn dummy_handler<'r>(_: Status, _: &'r Request<'_>, _: ErasedError<'r>) -> BoxFuture<'r> {
    Box::pin(async move { Ok(Response::new()) })
 }
 

core/lib/src/catcher/types.rs

@@ -1,4 +1,6 @@
-use transient::{Any, CanRecoverFrom, Co, Transient, Downcast};
+use transient::{Any, CanRecoverFrom, Co, Downcast};
+#[doc(inline)]
+pub use transient::{Static, Transient};
 
 pub type ErasedError<'r> = Box<dyn Any<Co<'r>> + Send + Sync + 'r>;
 pub type ErasedErrorRef<'r> = dyn Any<Co<'r>> + Send + Sync + 'r;
@@ -13,19 +15,23 @@ pub fn downcast<'a, 'r, T: Transient + 'r>(v: &'a ErasedErrorRef<'r>) -> Option<
     v.downcast_ref()
 }
 
-// /// Chosen not to expose this macro, since it's pretty short and sweet
-// #[doc(hidden)]
-// #[macro_export]
-// macro_rules! resolve_typed_catcher {
-//     ($T:expr) => ({
-//         #[allow(unused_imports)]
-//         use $crate::catcher::types::Resolve;
-//
-//         Resolve::new($T).cast()
-//     })
-// }
-
-// pub use resolve_typed_catcher;
+/// Upcasts a value to `ErasedError`, falling back to a default if it doesn't implement
+/// `Transient`
+#[doc(hidden)]
+#[macro_export]
+macro_rules! resolve_typed_catcher {
+    ($T:expr) => ({
+        #[allow(unused_imports)]
+        use $crate::catcher::resolution::{Resolve, DefaultTypeErase};
+
+        Resolve::new($T).cast()
+    });
+    () => ({
+        $crate::catcher::default_error_type()
+    });
+}
+
+pub use resolve_typed_catcher;
 
 pub mod resolution {
     use std::marker::PhantomData;