fix reversed nests

packages/router-macro/src/lib.rs

@@ -364,10 +364,7 @@ impl RouteEnum {
                     let parser = |input: ParseStream| {
                         let bang: Option<Token![!]> = input.parse().ok();
                         let exclude = bang.is_some();
-                        Ok((
+                        Ok((exclude, Layout::parse(input, nest_stack.clone())?))
-                            exclude,
-                            Layout::parse(input, nest_stack.iter().rev().cloned().collect())?,
-                        ))
                     };
                     let (exclude, layout): (bool, Layout) = attr.parse_args_with(parser)?;
 
@@ -389,19 +386,14 @@ impl RouteEnum {
                     layout_stack.pop();
                 } else if attr.path.is_ident("redirect") {
                     let parser = |input: ParseStream| {
-                        Redirect::parse(
+                        Redirect::parse(input, nest_stack.clone(), redirects.len())
-                            input,
-                            nest_stack.iter().rev().cloned().collect(),
-                            redirects.len(),
-                        )
                     };
                     let redirect = attr.parse_args_with(parser)?;
                     redirects.push(redirect);
                 }
             }
 
-            let mut active_nests = nest_stack.clone();
+            let active_nests = nest_stack.clone();
-            active_nests.reverse();
             let mut active_layouts = layout_stack.clone();
             active_layouts.retain(|&id| !excluded.contains(&id));
 

packages/router-macro/src/route.rs

@@ -186,26 +186,37 @@ impl Route {
     pub fn display_match(&self, nests: &[Nest]) -> TokenStream2 {
         let name = &self.route_name;
         let dynamic_segments = self.dynamic_segments();
-        let write_layouts = self.nests.iter().map(|id| nests[id.0].write());
-        let write_segments = self.segments.iter().map(|s| s.write_segment());
         let write_query = self.query.as_ref().map(|q| q.write());
 
         match &self.ty {
             RouteType::Child(field) => {
+                let write_nests = self.nests.iter().map(|id| nests[id.0].write());
+                let write_segments = self.segments.iter().map(|s| s.write_segment());
                 let child = field.ident.as_ref().unwrap();
                 quote! {
                     Self::#name { #(#dynamic_segments,)* #child } => {
                         use std::fmt::Display;
-                        #(#write_layouts)*
+                        use std::fmt::Write;
+                        let mut route = String::new();
+                        {
+                            let f = &mut route;
+                            #(#write_nests)*
                             #(#write_segments)*
-                        #child.fmt(f);
+                        }
+                        if route.ends_with('/') {
+                            route.pop();
+                        }
+                        f.write_str(&route)?;
+                        #child.fmt(f)?;
                     }
                 }
             }
             RouteType::Leaf { .. } => {
+                let write_nests = self.nests.iter().map(|id| nests[id.0].write());
+                let write_segments = self.segments.iter().map(|s| s.write_segment());
                 quote! {
                     Self::#name { #(#dynamic_segments,)* } => {
-                        #(#write_layouts)*
+                        #(#write_nests)*
                         #(#write_segments)*
                         #write_query
                     }

packages/router-macro/src/route_tree.rs

@@ -314,7 +314,7 @@ impl<'a> RouteTreeSegmentData<'a> {
                                 #(#children)*
                             }
                             else {
-                                errors.push(#error_enum_name::#enum_varient(#varient_parse_error::#error_ident))
+                                errors.push(#error_enum_name::#enum_varient(#varient_parse_error::#error_ident(segment.to_string())))
                             }
                         }
                     }

packages/router-macro/src/segment.rs

@@ -58,10 +58,11 @@ impl RouteSegment {
                 quote! {
                     {
                         let mut segments = segments.clone();
-                        let parsed = if let Some(#segment) = segments.next() {
+                        let segment = segments.next();
+                        let parsed = if let Some(#segment) = segment {
                             Ok(())
                         } else {
-                            Err(#error_enum_name::#error_enum_varient(#inner_parse_enum::#error_name))
+                            Err(#error_enum_name::#error_enum_varient(#inner_parse_enum::#error_name(segment.map(|s|s.to_string()).unwrap_or_default())))
                         };
                         match parsed {
                             Ok(_) => {
@@ -234,8 +235,8 @@ pub(crate) fn create_error_type(
         let error_name = segment.error_name(i);
         match segment {
             RouteSegment::Static(index) => {
-                error_variants.push(quote! { #error_name });
+                error_variants.push(quote! { #error_name(String) });
-                display_match.push(quote! { Self::#error_name => write!(f, "Static segment '{}' did not match", #index)? });
+                display_match.push(quote! { Self::#error_name(found) => write!(f, "Static segment '{}' did not match instead found '{found}'", #index)? });
             }
             RouteSegment::Dynamic(ident, ty) => {
                 let missing_error = segment.missing_error_name().unwrap();

packages/router/examples/simple_routes.rs

@@ -96,7 +96,8 @@ fn Route3(cx: Scope, dynamic: String) -> Element {
         p { "Site Map" }
         pre { "{site_map:#?}" }
         p { "Dynamic link" }
-        if let Ok(route) = parsed {
+        match parsed {
+            Ok(route) => {
                 if route != current_route {
                     render! {
                         Link {
@@ -109,8 +110,14 @@ fn Route3(cx: Scope, dynamic: String) -> Element {
                     None
                 }
             }
-        else {
+            Err(err) => {
-            None
+                render! {
+                    pre {
+                        color: "red",
+                        "Invalid route:\n{err}"
+                    }
+                }
+            }
         }
     }
 }
@@ -118,6 +125,7 @@ fn Route3(cx: Scope, dynamic: String) -> Element {
 #[rustfmt::skip]
 #[derive(Clone, Debug, PartialEq, Routable)]
 enum Route {
+    #[nest("/test")]
         // Nests with parameters have types taken from child routes
         #[nest("/user/:user_id")]
             // Everything inside the nest has the added parameter `user_id: usize`
@@ -137,6 +145,7 @@ enum Route {
                 Route2 { user_id: usize },
             #[end_layout]
         #[end_nest]
+    #[end_nest]
     #[redirect("/:id/user", |id: usize| Route::Route3 { dynamic: id.to_string()})]
     #[route("/:dynamic")]
     Route3 { dynamic: String },