wip: polish

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

@@ -42,6 +42,7 @@ pub struct Arguments {
 /// The parsed `#[route(..)]` attribute.
 #[derive(Debug, FromMeta)]
 pub struct Attribute {
+    #[meta(naked)]
     pub uri: RouteUri,
     pub method: Option<SpanWrapped<Method>>,
     pub data: Option<SpanWrapped<Dynamic>>,

core/codegen/tests/route.rs

@@ -54,8 +54,8 @@ fn post1(
 }
 
 #[route(
+    "/<a>/<name>/name/<path..>?sky=blue&<sky>&<query..>",
     method = POST,
-    uri = "/<a>/<name>/name/<path..>?sky=blue&<sky>&<query..>",
     format = "json",
     data = "<simple>",
     rank = 138

core/lib/Cargo.toml

@@ -74,7 +74,6 @@ 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"
-rustc-hash = "1.1"
 
 # tracing
 tracing = { version = "0.1.40", default-features = false, features = ["std", "attributes"] }

core/lib/fuzz/targets/collision-matching.rs

@@ -16,15 +16,15 @@ struct ArbitraryRequestData<'a> {
 
 #[derive(Arbitrary)]
 struct ArbitraryRouteData<'a> {
-    method: ArbitraryMethod,
+    method: Option<ArbitraryMethod>,
     uri: ArbitraryRouteUri<'a>,
     format: Option<ArbitraryMediaType>,
 }
 
 impl std::fmt::Debug for ArbitraryRouteData<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("ArbitraryRouteData")
-            .field("method", &self.method.0)
+            .field("method", &self.method.map(|v| v.0))
             .field("base", &self.uri.0.base())
             .field("unmounted", &self.uri.0.unmounted().to_string())
             .field("uri", &self.uri.0.to_string())
@@ -59,12 +59,14 @@ impl<'c, 'a: 'c> ArbitraryRequestData<'a> {
 
 impl<'a> ArbitraryRouteData<'a> {
     fn into_route(self) -> Route {
-        let mut r = Route::ranked(0, self.method.0, &self.uri.0.to_string(), dummy_handler);
+        let method = self.method.map(|m| m.0);
+        let mut r = Route::ranked(0, method, &self.uri.0.to_string(), dummy_handler);
         r.format = self.format.map(|f| f.0);
         r
     }
 }
 
+#[derive(Clone, Copy)]
 struct ArbitraryMethod(Method);
 
 struct ArbitraryOrigin<'a>(Origin<'a>);
@@ -79,12 +81,7 @@ struct ArbitraryRouteUri<'a>(RouteUri<'a>);
 
 impl<'a> Arbitrary<'a> for ArbitraryMethod {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        let all_methods = &[
-            Method::Get, Method::Put, Method::Post, Method::Delete, Method::Options,
-            Method::Head, Method::Trace, Method::Connect, Method::Patch
-        ];
-
-        Ok(ArbitraryMethod(*u.choose(all_methods)?))
+        Ok(ArbitraryMethod(*u.choose(Method::ALL_VARIANTS)?))
     }
 
     fn size_hint(_: usize) -> (usize, Option<usize>) {

core/lib/src/phase.rs

@@ -4,7 +4,7 @@ use figment::Figment;
 use crate::listener::Endpoint;
 use crate::shutdown::Stages;
 use crate::{Catcher, Config, Rocket, Route};
-use crate::router::Router;
+use crate::router::{Router, Finalized};
 use crate::fairing::Fairings;
 
 mod private {
@@ -100,7 +100,7 @@ phases! {
     /// represents a fully built and finalized application server ready for
     /// launch into orbit. See [`Rocket#ignite`] for full details.
     Ignite (#[derive(Debug)] Igniting) {
-        pub(crate) router: Router,
+        pub(crate) router: Router<Finalized>,
         pub(crate) fairings: Fairings,
         pub(crate) figment: Figment,
         pub(crate) config: Config,
@@ -114,7 +114,7 @@ phases! {
     /// An instance of `Rocket` in this phase is typed as [`Rocket<Orbit>`] and
     /// represents a running application.
     Orbit (#[derive(Debug)] Orbiting) {
-        pub(crate) router: Router,
+        pub(crate) router: Router<Finalized>,
         pub(crate) fairings: Fairings,
         pub(crate) figment: Figment,
         pub(crate) config: Config,

core/lib/src/rocket.rs

@@ -557,9 +557,10 @@ impl Rocket<Build> {
 
         // Initialize the router; check for collisions.
         let mut router = Router::new();
-        self.routes.clone().into_iter().for_each(|r| router.add_route(r));
-        self.catchers.clone().into_iter().for_each(|c| router.add_catcher(c));
-        router.finalize().map_err(|(r, c)| ErrorKind::Collisions { routes: r, catchers: c, })?;
+        self.routes.clone().into_iter().for_each(|r| router.routes.push(r));
+        self.catchers.clone().into_iter().for_each(|c| router.catchers.push(c));
+        let router = router.finalize()
+            .map_err(|(r, c)| ErrorKind::Collisions { routes: r, catchers: c, })?;
 
         // Finally, freeze managed state for faster access later.
         self.state.freeze();
@@ -840,8 +841,8 @@ impl<P: Phase> Rocket<P> {
     pub fn routes(&self) -> impl Iterator<Item = &Route> {
         match self.0.as_ref() {
             StateRef::Build(p) => Either::Left(p.routes.iter()),
-            StateRef::Ignite(p) => Either::Right(p.router.routes()),
-            StateRef::Orbit(p) => Either::Right(p.router.routes()),
+            StateRef::Ignite(p) => Either::Right(p.router.routes.iter()),
+            StateRef::Orbit(p) => Either::Right(p.router.routes.iter()),
         }
     }
 
@@ -871,8 +872,8 @@ impl<P: Phase> Rocket<P> {
     pub fn catchers(&self) -> impl Iterator<Item = &Catcher> {
         match self.0.as_ref() {
             StateRef::Build(p) => Either::Left(p.catchers.iter()),
-            StateRef::Ignite(p) => Either::Right(p.router.catchers()),
-            StateRef::Orbit(p) => Either::Right(p.router.catchers()),
+            StateRef::Ignite(p) => Either::Right(p.router.catchers.iter()),
+            StateRef::Orbit(p) => Either::Right(p.router.catchers.iter()),
         }
     }
 

core/lib/src/route/route.rs

@@ -22,7 +22,7 @@ use crate::sentinel::Sentry;
 ///
 /// let route = routes![route_name].remove(0);
 /// assert_eq!(route.name.unwrap(), "route_name");
-/// assert_eq!(route.method, Method::Get);
+/// assert_eq!(route.method, Some(Method::Get));
 /// assert_eq!(route.uri, "/route/<path..>?query");
 /// assert_eq!(route.rank, 2);
 /// assert_eq!(route.format.unwrap(), MediaType::JSON);
@@ -203,7 +203,7 @@ impl Route {
     /// // this is a route matching requests to `GET /`
     /// let index = Route::new(Method::Get, "/", handler);
     /// assert_eq!(index.rank, -9);
-    /// assert_eq!(index.method, Method::Get);
+    /// assert_eq!(index.method, Some(Method::Get));
     /// assert_eq!(index.uri, "/");
     /// ```
     #[track_caller]
@@ -233,12 +233,12 @@ impl Route {
     ///
     /// let foo = Route::ranked(1, Method::Post, "/foo?bar", handler);
     /// assert_eq!(foo.rank, 1);
-    /// assert_eq!(foo.method, Method::Post);
+    /// assert_eq!(foo.method, Some(Method::Post));
     /// assert_eq!(foo.uri, "/foo?bar");
     ///
     /// let foo = Route::ranked(None, Method::Post, "/foo?bar", handler);
     /// assert_eq!(foo.rank, -12);
-    /// assert_eq!(foo.method, Method::Post);
+    /// assert_eq!(foo.method, Some(Method::Post));
     /// assert_eq!(foo.uri, "/foo?bar");
     /// ```
     #[track_caller]