follow-up

actix-web-codegen/src/route.rs

@@ -328,8 +328,8 @@ pub struct Route {
     /// Name of the handler function being annotated.
     name: syn::Ident,
 
-    /// function generic
+    /// Handler function generics.
-    type_generic: Option<syn::TypeParam>,
+    generics: syn::Generics,
 
     /// Args passed to routing macro.
     ///
@@ -347,12 +347,7 @@ impl Route {
     pub fn new(args: RouteArgs, ast: syn::ItemFn, method: Option<MethodType>) -> syn::Result<Self> {
         let name = ast.sig.ident.clone();
 
-        let generics = ast.sig.generics.params.clone();
+        let generics = ast.sig.generics.clone();
-        let type_generic = if let Some(syn::GenericParam::Type(ty)) = generics.into_iter().next() {
-            Some(ty)
-        } else {
-            None
-        };
 
         // Try and pull out the doc comments so that we can reapply them to the generated struct.
         // Note that multi line doc comments are converted to multiple doc attributes.
@@ -380,7 +375,7 @@ impl Route {
         }
 
         Ok(Self {
-            type_generic,
+            generics,
             name,
             args: vec![args],
             ast,
@@ -391,12 +386,7 @@ impl Route {
     fn multiple(args: Vec<Args>, ast: syn::ItemFn) -> syn::Result<Self> {
         let name = ast.sig.ident.clone();
 
-        let generics = ast.sig.generics.params.clone();
+        let generics = ast.sig.generics.clone();
-        let type_generic = if let Some(syn::GenericParam::Type(ty)) = generics.into_iter().next() {
-            Some(ty)
-        } else {
-            None
-        };
 
         // Try and pull out the doc comments so that we can reapply them to the generated struct.
         // Note that multi line doc comments are converted to multiple doc attributes.
@@ -416,7 +406,7 @@ impl Route {
 
         Ok(Self {
             name,
-            type_generic,
+            generics,
             args,
             ast,
             doc_attributes,
@@ -428,7 +418,7 @@ impl ToTokens for Route {
     fn to_tokens(&self, output: &mut TokenStream2) {
         let Self {
             name,
-            type_generic,
+            generics,
             ast,
             args,
             doc_attributes,
@@ -441,16 +431,53 @@ impl ToTokens for Route {
         #[cfg(feature = "compat-routing-macros-force-pub")]
         let vis = syn::Visibility::Public(<Token![pub]>::default());
 
-        let (struct_generic, trait_generic, impl_type_generic) =
+        let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-            if let Some(syn::TypeParam { ident, bounds, .. }) = type_generic {
+
-                (
+        let mut struct_generics = generics.clone();
-                    Some(quote! { <#ident> (core::marker::PhantomData<T>) }),
+        struct_generics.where_clause = None;
-                    Some(quote! { <#ident: #bounds + 'static> }),
+
-                    Some(quote! { <#ident> }),
+        let phantom_args: Vec<TokenStream2> = generics
-                )
+            .params
-            } else {
+            .iter()
-                (None, None, None)
+            .map(|param| match param {
-            };
+                syn::GenericParam::Type(ty) => {
+                    let ident = &ty.ident;
+                    quote! { #ident }
+                }
+                syn::GenericParam::Lifetime(lt) => {
+                    let lifetime = &lt.lifetime;
+                    quote! { &#lifetime () }
+                }
+                syn::GenericParam::Const(konst) => {
+                    let ident = &konst.ident;
+                    quote! { [(); #ident] }
+                }
+            })
+            .collect();
+
+        let phantom_tuple = quote! { (#(#phantom_args, )*) };
+
+        let turbofish_args: Vec<TokenStream2> = generics
+            .params
+            .iter()
+            .filter_map(|param| match param {
+                syn::GenericParam::Type(ty) => {
+                    let ident = &ty.ident;
+                    Some(quote! { #ident })
+                }
+                syn::GenericParam::Const(konst) => {
+                    let ident = &konst.ident;
+                    Some(quote! { #ident })
+                }
+                syn::GenericParam::Lifetime(_) => None,
+            })
+            .collect();
+
+        let turbofish = if turbofish_args.is_empty() {
+            TokenStream2::new()
+        } else {
+            quote! { ::<#(#turbofish_args),*> }
+        };
 
         let registrations: TokenStream2 = args
             .iter()
@@ -484,31 +511,35 @@ impl ToTokens for Route {
                     }
                 };
 
-                let type_generic = if let Some(syn::TypeParam { ident, .. }) = type_generic {
-                    Some(quote! { ::<#ident> })
-                } else {
-                    None
-                };
-
                 quote! {
                     let __resource = ::actix_web::Resource::new(#path)
                         .name(#resource_name)
                         #method_guards
                         #(.guard(::actix_web::guard::fn_guard(#guards)))*
                         #(.wrap(#wrappers))*
-                        .to(#name #type_generic);
+                        .to(#name #turbofish);
                     ::actix_web::dev::HttpServiceFactory::register(__resource, __config);
                 }
             })
             .collect();
 
+        let struct_def = if generics.params.is_empty() {
+            quote! { #vis struct #name; }
+        } else {
+            quote! {
+                #vis struct #name #struct_generics (core::marker::PhantomData<#phantom_tuple>)
+                #where_clause;
+            }
+        };
+
         let stream = quote! {
             #(#doc_attributes)*
             #[allow(non_camel_case_types)]
             #[derive(Default)]
-            #vis struct #name #struct_generic;
+            #struct_def
 
-            impl #trait_generic ::actix_web::dev::HttpServiceFactory for #name #impl_type_generic
+            impl #impl_generics ::actix_web::dev::HttpServiceFactory for #name #ty_generics
+            #where_clause
             {
                 fn register(self, __config: &mut actix_web::dev::AppService) {
                     #ast

actix-web-codegen/tests/trybuild.rs

@@ -7,6 +7,7 @@ fn compile_macros() {
     t.compile_fail("tests/trybuild/simple-fail.rs");
 
     t.pass("tests/trybuild/route-ok.rs");
+    t.pass("tests/trybuild/route-generic-ok.rs");
     t.compile_fail("tests/trybuild/route-missing-method-fail.rs");
     t.compile_fail("tests/trybuild/route-duplicate-method-fail.rs");
     t.compile_fail("tests/trybuild/route-malformed-path-fail.rs");

actix-web-codegen/tests/trybuild/route-generic-ok.rs

@@ -0,0 +1,50 @@
+use actix_web::{get, web, App};
+
+trait UserRepository {
+    fn get_user(&self) -> u64;
+}
+
+#[derive(Clone)]
+struct UserClient;
+
+impl UserRepository for UserClient {
+    fn get_user(&self) -> u64 {
+        99
+    }
+}
+
+#[derive(Clone)]
+struct Flag;
+
+#[get("/")]
+async fn index<T>(client: web::Data<T>) -> String
+where
+    T: UserRepository + Send + Sync + 'static,
+{
+    client.get_ref().get_user().to_string()
+}
+
+#[get("/multi")]
+async fn multi<T, U>(client: web::Data<T>, _flag: web::Data<U>) -> String
+where
+    T: UserRepository + Send + Sync + 'static,
+    U: Clone + Send + Sync + 'static,
+{
+    client.get_ref().get_user().to_string()
+}
+
+#[get("/const")]
+async fn with_const<const N: usize>() -> String {
+    format!("{N}")
+}
+
+fn main() {
+    let app = App::new()
+        .app_data(web::Data::new(UserClient))
+        .app_data(web::Data::new(Flag))
+        .service(index::<UserClient>::default())
+        .service(multi::<UserClient, Flag>::default())
+        .service(with_const::<3>::default());
+
+    let _ = app;
+}

actix-web/Cargo.toml

@@ -5,10 +5,10 @@ description = "Actix Web is a powerful, pragmatic, and extremely fast web framew
 authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
 keywords = ["actix", "http", "web", "framework", "async"]
 categories = [
-	"network-programming",
+  "network-programming",
-	"asynchronous",
+  "asynchronous",
-	"web-programming::http-server",
+  "web-programming::http-server",
-	"web-programming::websocket",
+  "web-programming::websocket",
 ]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web"
@@ -18,17 +18,17 @@ rust-version.workspace = true
 
 [package.metadata.docs.rs]
 features = [
-	"macros",
+  "macros",
-	"openssl",
+  "openssl",
-	"rustls-0_20",
+  "rustls-0_20",
-	"rustls-0_21",
+  "rustls-0_21",
-	"rustls-0_22",
+  "rustls-0_22",
-	"rustls-0_23",
+  "rustls-0_23",
-	"compress-brotli",
+  "compress-brotli",
-	"compress-gzip",
+  "compress-gzip",
-	"compress-zstd",
+  "compress-zstd",
-	"cookies",
+  "cookies",
-	"secure-cookies",
+  "secure-cookies",
 ]
 
 [package.metadata.cargo_check_external_types]
@@ -58,15 +58,15 @@ allowed_external_types = [
 
 [features]
 default = [
-	"macros",
+  "macros",
-	"compress-brotli",
+  "compress-brotli",
-	"compress-gzip",
+  "compress-gzip",
-	"compress-zstd",
+  "compress-zstd",
-	"cookies",
+  "cookies",
-	"http2",
+  "http2",
-	"unicode",
+  "unicode",
-	"compat",
+  "compat",
-	"ws",
+  "ws",
 ]
 
 # Brotli algorithm content-encoding support
@@ -203,10 +203,6 @@ required-features = ["compress-brotli", "compress-gzip", "compress-zstd"]
 name = "basic"
 required-features = ["compress-gzip"]
 
-[[example]]
-name = "issue"
-path = "examples/2866.rs"
-
 [[example]]
 name = "uds"
 required-features = ["compress-gzip"]

actix-web/examples/2866.rs

@@ -1,60 +0,0 @@
-use actix_web::{
-    dev::Server,
-    get,
-    web::{self, Data},
-    App, HttpServer, Responder,
-};
-use serde::Serialize;
-
-#[derive(Debug, Serialize, Clone, Copy)]
-pub struct User {
-    id: u64,
-}
-
-pub trait UserRepository {
-    fn get_user(&self) -> User;
-}
-
-#[derive(Clone)]
-struct UserClient;
-
-impl UserRepository for UserClient {
-    fn get_user(&self) -> User {
-        User { id: 99 }
-    }
-}
-
-// when uncommenting following the line, the type checking is unaccepted
-// because of cannot infer type parameter T
-#[get("/")]
-async fn index<T: UserRepository>(client: web::Data<T>) -> impl Responder {
-    let user = client.into_inner().get_user();
-    web::Json(user)
-}
-
-#[get("hello/{who}")]
-async fn hello(who: web::Path<String>) -> impl Responder {
-    format!("<h1>hello {who}</h1>")
-}
-
-pub fn create_server<T: UserRepository + Send + Sync + 'static + Clone>(
-    search: T,
-) -> Result<Server, std::io::Error> {
-    let server = HttpServer::new(move || {
-        App::new()
-            .app_data(Data::new(search.clone()))
-            // .route("/", web::get().to(index::<T>))
-            .service(index::<T>(core::marker::PhantomData::<T>))
-            .service(hello)
-    })
-    .bind("127.0.0.1:8080")?
-    .run();
-    Ok(server)
-}
-
-#[actix_web::main]
-async fn main() -> std::io::Result<()> {
-    println!("\x1b[1;2;36mserving on http://localhost:8080\x1b[0m");
-    let user_client = UserClient;
-    create_server(user_client).unwrap().await
-}