Switch from route-recognizer to matchit (#4096)

* feat(yew-router)!: switch from route-recognizer to matchit

Migrate `yew-router` from the unmaintained `route-recognizer` crate to
`matchit`, aligning route parameter syntax with Axum and the broader
Rust ecosystem (`:param` → `{param}`, `*wildcard` → `{*wildcard}`).

* fix(yew-router): include route pattern and error in build_router panic

matchit has stricter conflict detection than route-recognizer, so
users migrating with ambiguous routes (e.g. `/{id}` and `/{name}`)
will hit this panic. The old message ("failed to insert route") gave
no indication of which route or why; now it shows both.

* fix(yew-router-macro): reject route params without corresponding fields

A unit variant like `Settings` with `#[at("/settings/{*_rest}")]`
compiled but produced a broken `to_path()` that returned the literal
pattern string. This was a pre-existing bug (same with the old
`*rest` syntax) now caught at compile time.

Also fixes the nested-router docs examples to use named fields.

* fix(yew-router-macro): reject old `:param` and `*param` route syntax

Under matchit, the old route-recognizer syntax silently becomes literal
path segments, causing routes to never match. Emit a compile-time error
with a suggested fix instead.

Author: Madoshakalaka

Cargo.lock

@@ -25,11 +25,11 @@ pub fn route_meta(route: &Route) -> (&'static str, &'static str) {
 
 #[derive(Routable, PartialEq, Eq, Clone, Debug)]
 pub enum Route {
-    #[at("/posts/:id")]
+    #[at("/posts/{id}")]
     Post { id: u32 },
     #[at("/posts")]
     Posts,
-    #[at("/authors/:id")]
+    #[at("/authors/{id}")]
     Author { id: u32 },
     #[at("/authors")]
     Authors,

examples/function_router/src/app.rs

@@ -15,11 +15,11 @@ use yew::html::Scope;
 
 #[derive(Routable, PartialEq, Eq, Clone, Debug)]
 pub enum Route {
-    #[at("/posts/:id")]
+    #[at("/posts/{id}")]
     Post { id: u64 },
     #[at("/posts")]
     Posts,
-    #[at("/authors/:id")]
+    #[at("/authors/{id}")]
     Author { id: u64 },
     #[at("/authors")]
     Authors,

examples/router/src/main.rs

@@ -6,7 +6,7 @@ pub enum Route {
     #[at("/")]
     Portal,
 
-    #[at("/t/:id")]
+    #[at("/t/{id}")]
     Thread { id: String },
 
     #[not_found]

examples/wasi_ssr_module/src/router.rs

@@ -8,6 +8,25 @@ use syn::{Data, DeriveInput, Fields, Ident, LitStr, Variant};
 const AT_ATTR_IDENT: &str = "at";
 const NOT_FOUND_ATTR_IDENT: &str = "not_found";
 
+/// Extract parameter names from a matchit-style route pattern.
+/// E.g. `"/posts/{id}"` → `["id"]`, `"/files/{*path}"` → `["path"]`.
+fn extract_route_params(route: &str) -> Vec<String> {
+    let mut params = Vec::new();
+    let mut chars = route.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '{' {
+            if chars.peek() == Some(&'*') {
+                chars.next();
+            }
+            let name: String = chars.by_ref().take_while(|&c| c != '}').collect();
+            if !name.is_empty() {
+                params.push(name);
+            }
+        }
+    }
+    params
+}
+
 pub struct Routable {
     ident: Ident,
     ats: Vec<LitStr>,
@@ -101,6 +120,55 @@ fn parse_variants_attributes(
             ));
         }
 
+        // Reject old route-recognizer `:param` / `*param` syntax that would
+        // silently become literal path segments under matchit.
+        for segment in val.split('/') {
+            if let Some(name) = segment.strip_prefix(':') {
+                return Err(syn::Error::new_spanned(
+                    &lit,
+                    format!(
+                        "route segments must not start with `:`. Use `{{{name}}}` to capture a \
+                         parameter.",
+                    ),
+                ));
+            }
+            if let Some(name) = segment.strip_prefix('*') {
+                return Err(syn::Error::new_spanned(
+                    &lit,
+                    format!(
+                        "route segments must not start with `*`. Use `{{*{name}}}` to capture a \
+                         wildcard.",
+                    ),
+                ));
+            }
+        }
+
+        let route_params = extract_route_params(&val);
+        if !route_params.is_empty() {
+            let field_names: std::collections::HashSet<String> = match &variant.fields {
+                Fields::Named(fields) => fields
+                    .named
+                    .iter()
+                    .filter_map(|f| f.ident.as_ref().map(|i| i.to_string()))
+                    .collect(),
+                Fields::Unit => std::collections::HashSet::new(),
+                Fields::Unnamed(_) => unreachable!(),
+            };
+
+            for param in &route_params {
+                if !field_names.contains(param) {
+                    return Err(syn::Error::new_spanned(
+                        &lit,
+                        format!(
+                            "route parameter `{param}` does not have a corresponding field in \
+                             variant `{}`",
+                            variant.ident
+                        ),
+                    ));
+                }
+            }
+        }
+
         ats.push(lit);
 
         for attr in attrs.iter() {
@@ -174,14 +242,13 @@ impl Routable {
 
                     let mut wildcard_fields = std::collections::HashSet::new();
                     for field in fields.iter() {
-                        if right.contains(&format!("*{field}")) {
+                        if right.contains(&format!("{{*{field}}}")) {
                             wildcard_fields.insert((*field).clone());
                         }
-                        // :param -> {param}
-                        // *param -> {param}
-                        // so we can pass it to `format!("...", param)`
-                        right = right.replace(&format!(":{field}"), &format!("{{{field}}}"));
-                        right = right.replace(&format!("*{field}"), &format!("{{{field}}}"));
+                        // {*param} -> {param} so we can pass it to `format!("...", param)`
+                        // {param} is already valid format syntax
+                        right =
+                            right.replace(&format!("{{*{field}}}"), &format!("{{{field}}}"));
                     }
 
                     let field_encodings = fields.iter().map(|field| {

packages/yew-router-macro/src/routable_derive.rs

@@ -0,0 +1,11 @@
+#[derive(yew_router::Routable, Debug, Clone, PartialEq)]
+enum Routes {
+    #[at("/")]
+    Home,
+    #[at("/posts/:id")]
+    Post { id: u32 },
+    #[at("/files/*path")]
+    File { path: String },
+}
+
+fn main() {}

packages/yew-router-macro/tests/routable_derive/old-param-syntax-fail.rs

@@ -0,0 +1,5 @@
+error: route segments must not start with `:`. Use `{id}` to capture a parameter.
+ --> tests/routable_derive/old-param-syntax-fail.rs:5:10
+  |
+5 |     #[at("/posts/:id")]
+  |          ^^^^^^^^^^^^

packages/yew-router-macro/tests/routable_derive/old-param-syntax-fail.stderr

@@ -0,0 +1,9 @@
+#[derive(yew_router::Routable, Debug, Clone, PartialEq)]
+enum Routes {
+    #[at("/")]
+    Home,
+    #[at("/settings/{*_rest}")]
+    Settings,
+}
+
+fn main() {}

packages/yew-router-macro/tests/routable_derive/param-without-field-fail.rs

@@ -0,0 +1,5 @@
+error: route parameter `_rest` does not have a corresponding field in variant `Settings`
+ --> tests/routable_derive/param-without-field-fail.rs:5:10
+  |
+5 |     #[at("/settings/{*_rest}")]
+  |          ^^^^^^^^^^^^^^^^^^^^

packages/yew-router-macro/tests/routable_derive/param-without-field-fail.stderr

@@ -1,6 +1,6 @@
 #[derive(yew_router::Routable)]
 enum Routes {
-    #[at("/one/:two")]
+    #[at("/one/{two}")]
     One(u32),
 }