feat: let delegate_noop can handle constGeneric

the macro of delegate_noop cannot handle like
struct A<const X: unsize>, such kind of struct, so I want to fix it

wayland-client/CHANGELOG.md

@@ -11,6 +11,7 @@
 
 - Implement `AsFd` for `Connection` and `EventQueue` so they can easily be used in a
   `calloop` source.
+- Make `delegate_noop` usable for constGeneric type.
 
 ## 0.31.0 -- 2023-09-02
 

wayland-client/src/event_queue.rs

@@ -807,6 +807,28 @@ macro_rules! delegate_dispatch {
             }
         }
     };
+
+    ($(@< $( const $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $dispatch_from:ty : [$interface: ty: $udata: ty] => $dispatch_to: ty) => {
+        impl$(< $( const $lt $( : $clt $(+ $dlt )* )? ),+ >)? $crate::Dispatch<$interface, $udata> for $dispatch_from {
+            fn event(
+                state: &mut Self,
+                proxy: &$interface,
+                event: <$interface as $crate::Proxy>::Event,
+                data: &$udata,
+                conn: &$crate::Connection,
+                qhandle: &$crate::QueueHandle<Self>,
+            ) {
+                <$dispatch_to as $crate::Dispatch<$interface, $udata, Self>>::event(state, proxy, event, data, conn, qhandle)
+            }
+
+            fn event_created_child(
+                opcode: u16,
+                qhandle: &$crate::QueueHandle<Self>
+            ) -> ::std::sync::Arc<dyn $crate::backend::ObjectData> {
+                <$dispatch_to as $crate::Dispatch<$interface, $udata, Self>>::event_created_child(opcode, qhandle)
+            }
+        }
+    };
 }
 
 /// A helper macro which delegates a set of [`Dispatch`] implementations for proxies to a static handler.
@@ -831,13 +853,28 @@ macro_rules! delegate_dispatch {
 ///
 /// // This interface should not emit events:
 /// delegate_noop!(ExampleApp: wl_subcompositor::WlSubcompositor);
+///
+/// // Also you can do it with generic type, for example
+/// struct ExampleAppGeneric<const X: usize>;
+/// delegate_noop!(@<const X: usize> ExampleAppGeneric<X>: ignore wl_data_offer::WlDataOffer);
+/// delegate_noop!(@<const X: usize> ExampleAppGeneric<X>: wl_subcompositor::WlSubcompositor);
+///
+/// // @ is to start with generic, and for base generic type looks like below.
+/// trait E {
+///    // add code here
+/// }
+/// struct ExampleAppGeneric2<T: E> {
+///     a: T
+/// }
+/// delegate_noop!(@<T: E> ExampleAppGeneric2<T>: wl_data_offer::WlDataOffer);
+/// delegate_noop!(@<T: E> ExampleAppGeneric2<T>: ignore wl_subcompositor::WlSubcompositor);
 /// ```
 ///
 /// This last example will execute `unreachable!()` if the interface emits any events.
 #[macro_export]
 macro_rules! delegate_noop {
-    ($(@< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $dispatch_from: ty : $interface: ty) => {
-        impl$(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $crate::Dispatch<$interface, ()> for $dispatch_from {
+    ($(@< $( $($lt:ident )+ $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $dispatch_from: ty : $interface: ty) => {
+        impl$(< $( $($lt )+ $( : $clt $(+ $dlt )* )? ),+ >)? $crate::Dispatch<$interface, ()> for $dispatch_from {
             fn event(
                 _: &mut Self,
                 _: &$interface,
@@ -851,8 +888,9 @@ macro_rules! delegate_noop {
         }
     };
 
-    ($(@< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $dispatch_from: ty : ignore $interface: ty) => {
-        impl$(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $crate::Dispatch<$interface, ()> for $dispatch_from {
+
+    ($(@< $( $($lt:ident )+ $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $dispatch_from: ty : ignore $interface: ty) => {
+        impl$(< $( $($lt )+ $( : $clt $(+ $dlt )* )? ),+ >)? $crate::Dispatch<$interface, ()> for $dispatch_from {
             fn event(
                 _: &mut Self,
                 _: &$interface,
@@ -864,4 +902,5 @@ macro_rules! delegate_noop {
             }
         }
     };
+
 }

wayland-server/CHANGELOG.md

@@ -10,6 +10,7 @@
 - Updated wayland-backend to 0.3
 - Use `BorrowedFd<'_>` arguments instead of `RawFd`
 - `Resource::destroyed` now passes the resource type instead of the `ObjectId`.
+- Make `delegate_dispatch` usable for constGeneric type.
 
 #### Additions
 

wayland-server/src/dispatch.rs

@@ -347,6 +347,11 @@ impl<I: Resource + 'static, U: Send + Sync + 'static, D: Dispatch<I, U> + 'stati
 ///     }
 /// }
 /// ```
+/// This macro_rules also support to be used with generic type, it will be similiar with client one
+/// like
+/// ```ignore
+/// delegate_dispatch!(@<const X : usize> ExampleApp<X>: [wl_output::WlOutput: MyUserData] => DelegateToMe);
+/// ```
 #[macro_export]
 macro_rules! delegate_dispatch {
     ($(@< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $dispatch_from:ty : [$interface: ty: $udata: ty] => $dispatch_to: ty) => {
@@ -368,4 +373,24 @@ macro_rules! delegate_dispatch {
             }
         }
     };
+
+    ($(@< $( const $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $dispatch_from:ty : [$interface: ty: $udata: ty] => $dispatch_to: ty) => {
+        impl$(< $( const $lt $( : $clt $(+ $dlt )* )? ),+ >)? $crate::Dispatch<$interface, $udata> for $dispatch_from {
+            fn request(
+                state: &mut Self,
+                client: &$crate::Client,
+                resource: &$interface,
+                request: <$interface as $crate::Resource>::Request,
+                data: &$udata,
+                dhandle: &$crate::DisplayHandle,
+                data_init: &mut $crate::DataInit<'_, Self>,
+            ) {
+                <$dispatch_to as $crate::Dispatch<$interface, $udata, Self>>::request(state, client, resource, request, data, dhandle, data_init)
+            }
+
+            fn destroyed(state: &mut Self, client: $crate::backend::ClientId, resource: &$interface, data: &$udata) {
+                <$dispatch_to as $crate::Dispatch<$interface, $udata, Self>>::destroyed(state, client, resource, data)
+            }
+        }
+    };
 }