Implement Debug for all types

Author: madsmtm

CHANGELOG.md

@@ -3,6 +3,7 @@
 - Update to `objc2` 0.6.0.
 - Bump MSRV to Rust 1.71.
 - Make `Context` clonable.
+- `Context`, `Surface` and `Buffer` now implement `Debug`.
 
 # 0.4.6
 

src/backend_dispatch.rs

@@ -3,6 +3,7 @@
 use crate::{backend_interface::*, backends, InitError, Rect, SoftBufferError};
 
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
+use std::fmt;
 use std::num::NonZeroU32;
 #[cfg(any(wayland_platform, x11_platform, kms_platform))]
 use std::sync::Arc;
@@ -56,6 +57,17 @@ macro_rules! make_dispatch {
             }
         }
 
+        impl<D: fmt::Debug> fmt::Debug for ContextDispatch<D> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.fmt(f),
+                    )*
+                }
+            }
+        }
+
         #[allow(clippy::large_enum_variant)] // it's boxed anyways
         pub(crate) enum SurfaceDispatch<$dgen, $wgen> {
             $(
@@ -117,6 +129,17 @@ macro_rules! make_dispatch {
             }
         }
 
+        impl<D: fmt::Debug, W: fmt::Debug> fmt::Debug for SurfaceDispatch<D, W> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.fmt(f),
+                    )*
+                }
+            }
+        }
+
         pub(crate) enum BufferDispatch<'a, $dgen, $wgen> {
             $(
                 $(#[$attr])*
@@ -172,6 +195,17 @@ macro_rules! make_dispatch {
                 }
             }
         }
+
+        impl<D: fmt::Debug, W: fmt::Debug> fmt::Debug for BufferDispatch<'_, D, W> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.fmt(f),
+                    )*
+                }
+            }
+        }
     };
 }
 

src/backends/android.rs

@@ -15,6 +15,7 @@ use crate::error::InitError;
 use crate::{BufferInterface, Rect, SoftBufferError, SurfaceInterface};
 
 /// The handle to a window for software buffering.
+#[derive(Debug)]
 pub struct AndroidImpl<D, W> {
     native_window: NativeWindow,
     window: W,
@@ -113,6 +114,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Android
     }
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D: ?Sized, W> {
     native_window_buffer: NativeWindowBufferLockGuard<'a>,
     buffer: Vec<u32>,

src/backends/cg.rs

@@ -28,6 +28,7 @@ define_class!(
     #[unsafe(super(NSObject))]
     #[name = "SoftbufferObserver"]
     #[ivars = SendCALayer]
+    #[derive(Debug)]
     struct Observer;
 
     /// NSKeyValueObserving
@@ -92,6 +93,7 @@ impl Observer {
     }
 }
 
+#[derive(Debug)]
 pub struct CGImpl<D, W> {
     /// Our layer.
     layer: SendCALayer,
@@ -263,6 +265,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for CGImpl<
     }
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D, W> {
     imp: &'a mut CGImpl<D, W>,
     buffer: Box<[u32]>,
@@ -344,6 +347,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_,
     }
 }
 
+#[derive(Debug)]
 struct SendCALayer(Retained<CALayer>);
 
 // SAFETY: CALayer is dubiously thread safe, like most things in Core Animation.

src/backends/kms.rs

@@ -12,6 +12,7 @@ use drm::Device;
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawDisplayHandle, RawWindowHandle};
 
 use std::collections::HashSet;
+use std::fmt;
 use std::marker::PhantomData;
 use std::num::NonZeroU32;
 use std::os::unix::io::{AsFd, BorrowedFd};
@@ -118,6 +119,13 @@ pub(crate) struct BufferImpl<'a, D: ?Sized, W: ?Sized> {
     _window: PhantomData<&'a mut W>,
 }
 
+impl<D: ?Sized + fmt::Debug, W: ?Sized + fmt::Debug> fmt::Debug for BufferImpl<'_, D, W> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // FIXME: Derive instead once `DumbMapping` impls `Debug`.
+        f.debug_struct("BufferImpl").finish_non_exhaustive()
+    }
+}
+
 /// The combined frame buffer and dumb buffer.
 #[derive(Debug)]
 struct SharedBuffer {

src/backends/orbital.rs

@@ -5,6 +5,7 @@ use std::{cmp, marker::PhantomData, num::NonZeroU32, slice, str};
 use crate::backend_interface::*;
 use crate::{Rect, SoftBufferError};
 
+#[derive(Debug)]
 struct OrbitalMap {
     address: usize,
     size: usize,
@@ -55,6 +56,7 @@ impl Drop for OrbitalMap {
     }
 }
 
+#[derive(Debug)]
 pub struct OrbitalImpl<D, W> {
     handle: ThreadSafeWindowHandle,
     width: u32,
@@ -64,6 +66,7 @@ pub struct OrbitalImpl<D, W> {
     _display: PhantomData<D>,
 }
 
+#[derive(Debug)]
 struct ThreadSafeWindowHandle(OrbitalWindowHandle);
 unsafe impl Send for ThreadSafeWindowHandle {}
 unsafe impl Sync for ThreadSafeWindowHandle {}
@@ -180,11 +183,13 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Orbital
     }
 }
 
+#[derive(Debug)]
 enum Pixels {
     Mapping(OrbitalMap),
     Buffer(Vec<u32>),
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D, W> {
     imp: &'a mut OrbitalImpl<D, W>,
     pixels: Pixels,

src/backends/wayland/buffer.rs

@@ -67,6 +67,7 @@ unsafe fn map_file(file: &File) -> MmapMut {
     unsafe { MmapMut::map_mut(file.as_raw_fd()).expect("Failed to map shared memory") }
 }
 
+#[derive(Debug)]
 pub(super) struct WaylandBuffer {
     qh: QueueHandle<State>,
     tempfile: File,

src/backends/wayland/mod.rs

@@ -20,6 +20,7 @@ use buffer::WaylandBuffer;
 
 struct State;
 
+#[derive(Debug)]
 pub struct WaylandDisplayImpl<D: ?Sized> {
     conn: Option<Connection>,
     event_queue: Mutex<EventQueue<State>>,
@@ -74,6 +75,7 @@ impl<D: ?Sized> Drop for WaylandDisplayImpl<D> {
     }
 }
 
+#[derive(Debug)]
 pub struct WaylandImpl<D: ?Sized, W: ?Sized> {
     display: Arc<WaylandDisplayImpl<D>>,
     surface: Option<wl_surface::WlSurface>,
@@ -257,6 +259,7 @@ impl<D: ?Sized, W: ?Sized> Drop for WaylandImpl<D, W> {
     }
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D: ?Sized, W> {
     stack: util::BorrowStack<'a, WaylandImpl<D, W>, [u32]>,
     age: u8,

src/backends/web.rs

@@ -18,7 +18,7 @@ use std::num::NonZeroU32;
 /// Display implementation for the web platform.
 ///
 /// This just caches the document to prevent having to query it every time.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct WebDisplayImpl<D> {
     document: web_sys::Document,
     _display: D,
@@ -43,6 +43,7 @@ impl<D: HasDisplayHandle> ContextInterface<D> for WebDisplayImpl<D> {
     }
 }
 
+#[derive(Debug)]
 pub struct WebImpl<D, W> {
     /// The handle and context to the canvas that we're drawing to.
     canvas: Canvas,
@@ -65,6 +66,7 @@ pub struct WebImpl<D, W> {
 
 /// Holding canvas and context for [`HtmlCanvasElement`] or [`OffscreenCanvas`],
 /// since they have different types.
+#[derive(Debug)]
 enum Canvas {
     Canvas {
         canvas: HtmlCanvasElement,
@@ -373,6 +375,7 @@ impl Canvas {
     }
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D, W> {
     imp: &'a mut WebImpl<D, W>,
 }

src/backends/win32.rs

@@ -25,6 +25,7 @@ const ZERO_QUAD: Gdi::RGBQUAD = Gdi::RGBQUAD {
     rgbReserved: 0,
 };
 
+#[derive(Debug)]
 struct Buffer {
     dc: Gdi::HDC,
     bitmap: Gdi::HBITMAP,
@@ -135,6 +136,7 @@ impl Buffer {
 }
 
 /// The handle to a window for software buffering.
+#[derive(Debug)]
 pub struct Win32Impl<D: ?Sized, W> {
     /// The window handle.
     window: OnlyUsedFromOrigin<HWND>,
@@ -281,6 +283,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Win32Im
     }
 }
 
+#[derive(Debug)]
 pub struct BufferImpl<'a, D, W>(&'a mut Win32Impl<D, W>);
 
 impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
@@ -460,6 +463,7 @@ impl Command {
     }
 }
 
+#[derive(Debug)]
 struct OnlyUsedFromOrigin<T>(T);
 unsafe impl<T> Send for OnlyUsedFromOrigin<T> {}