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

@@ -831,6 +831,21 @@ 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>: ignore 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.
@@ -851,6 +866,22 @@ macro_rules! delegate_noop {
         }
     };
 
+    // delegate_noop!(@<const X: unsize> ExampleApp<X>: wl_subcompositor::WlSubcompositor);
+    ($(@< $( const $lt:tt  $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $dispatch_from: ty : $interface: ty) => {
+        impl$(< $(const $lt $( : $clt $(+ $dlt )* )? ),+ >)? $crate::Dispatch<$interface, ()> for $dispatch_from {
+            fn event(
+                _: &mut Self,
+                _: &$interface,
+                _: <$interface as $crate::Proxy>::Event,
+                _: &(),
+                _: &$crate::Connection,
+                _: &$crate::QueueHandle<Self>,
+            ) {
+                unreachable!();
+            }
+        }
+    };
+
     ($(@< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $dispatch_from: ty : ignore $interface: ty) => {
         impl$(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $crate::Dispatch<$interface, ()> for $dispatch_from {
             fn event(
@@ -864,4 +895,19 @@ macro_rules! delegate_noop {
             }
         }
     };
+
+    // delegate_noop!(@<const X: unsize> ExampleApp<X>: ignore wl_subcompositor::WlSubcompositor);
+    ($(@< $( const $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $dispatch_from: ty : ignore $interface: ty) => {
+        impl$(< $( const $lt $( : $clt $(+ $dlt )* )? ),+ >)? $crate::Dispatch<$interface, ()> for $dispatch_from {
+            fn event(
+                _: &mut Self,
+                _: &$interface,
+                _: <$interface as $crate::Proxy>::Event,
+                _: &(),
+                _: &$crate::Connection,
+                _: &$crate::QueueHandle<Self>,
+            ) {
+            }
+        }
+    };
 }

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)
+            }
+        }
+    };
 }