Implement transparent pass-throughs for the remaining audit-layer stubs

Turns the ~113 todo!() stubs across Device, Queue, CommandEncoder, and
the rest of Adapter/Surface into calls that forward to `inner`,
allocating a fresh audit `Id` for each newly created resource. No new
safety checking is added here — this just makes the wrapper functionally
complete (usable end to end) instead of panicking on first use of
anything beyond instance creation and adapter enumeration.

Since `Audited<T>::inner` is already stored as the erased `Box<dyn
DynX>` the real backend expects, converting an audited-wrapper
descriptor into its `dyn` equivalent needs no downcasting — just `&self
.inner`. Added two small helpers to make that idiomatic:
`Audited::wrap` (allocate an id, wrap a freshly created inner resource)
and `Audited::as_dyn` (deref `inner` to its erased type). Descriptors
that are themselves generic over other resource types (BindGroupDescriptor,
RenderPipelineDescriptor, RenderPassDescriptor, BuildAccelerationStructureDescriptor,
etc.) get reconstructed field-by-field against their `dyn` equivalents,
mirroring the existing reverse-direction conversions in
wgpu-hal/src/dynamic/*.rs (which do the same job the other way, backend
-> dyn, complete with real downcasts since they don't have the luxury
of already holding the erased type).

Two methods are left as todo!(), each with a comment explaining why:

- `Surface::acquire_texture` needs to cache an owned `audit::Texture` so
  `Borrow<audit::Texture>` has something to point to, but the only
  texture available is a *borrowed* view of the inner surface texture.
  Manufacturing an owned `Box<dyn DynTexture>` from that borrow would
  need either downcasting to a concrete backend type (this layer is
  backend-agnostic) or aliasing `inner`'s allocation (double-free once
  both boxes drop). Needs an actual design change, not a mechanical fix.
- `CommandEncoder::set_acceleration_structure_dependencies` is declared
  as a receiverless associated function in the static `CommandEncoder`
  trait, so there is no `self.inner` to forward to.

Added wgpu-hal/examples/audit_smoke.rs, a standalone example that drives
a real Vulkan instance through the auditing wrapper end to end (create
instance, enumerate adapters, open a device, write to a mapped buffer,
record+submit+wait on a command buffer) to exercise this. Verified with
`WGPU_AUDIT_HAL_USAGE=1 cargo run -p wgpu-hal --example audit_smoke
--features vulkan`, comparing against the same run with the env var
unset. `cargo check --workspace --features vulkan` and `cargo clippy -p
wgpu-hal --features vulkan --all-targets` are both clean.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: jimblandy

wgpu-hal/Cargo.toml

@@ -202,6 +202,10 @@ name = "halmark"
 name = "raw-gles"
 required-features = ["gles"]
 
+[[example]]
+name = "audit_smoke"
+required-features = ["vulkan"]
+
 #####################
 ### Platform: All ###
 #####################

wgpu-hal/examples/audit_smoke.rs

@@ -0,0 +1,121 @@
+//! A smoke test for `wgpu_hal::audit`.
+//!
+//! This drives a real Vulkan instance through the auditing wrapper end to
+//! end: enumerate adapters, open a device, create a buffer and write to it
+//! via mapping, then record and submit an (empty) command buffer and wait
+//! for it to finish. Every call in this program passes through
+//! `wgpu_hal::audit`'s `Audited` wrappers before reaching the real Vulkan
+//! backend.
+//!
+//! Run with `WGPU_AUDIT_HAL_USAGE` unset to compare against the
+//! unaudited path; the two should behave identically.
+
+use wgpu_hal::Instance as _;
+
+fn main() {
+    env_logger::init();
+    unsafe { run() };
+}
+
+unsafe fn run() {
+    let instance_desc = wgpu_hal::InstanceDescriptor {
+        name: "audit-smoke",
+        flags: wgpu_types::InstanceFlags::debugging(),
+        memory_budget_thresholds: Default::default(),
+        backend_options: Default::default(),
+        telemetry: None,
+        display: None,
+    };
+
+    let instance: Box<dyn wgpu_hal::DynInstance> = Box::new(
+        unsafe { <wgpu_hal::vulkan::Api as wgpu_hal::Api>::Instance::init(&instance_desc) }
+            .expect("failed to create a vulkan instance"),
+    );
+
+    let audit_enabled = std::env::var("WGPU_AUDIT_HAL_USAGE").is_ok_and(|v| v != "0");
+    let instance = if audit_enabled {
+        println!("WGPU_AUDIT_HAL_USAGE set: wrapping the instance in the auditing layer");
+        wgpu_hal::audit::new_auditing_instance(
+            instance,
+            wgpu_types::Backend::Vulkan,
+            wgpu_hal::audit::report_by_log(log::Level::Info),
+        )
+    } else {
+        println!("WGPU_AUDIT_HAL_USAGE not set: using the instance unaudited");
+        instance
+    };
+
+    let exposed = unsafe { instance.enumerate_adapters(None) }
+        .into_iter()
+        .next()
+        .expect("no adapters found");
+    println!("Using adapter: {}", exposed.info.name);
+
+    let open_device = unsafe {
+        exposed.adapter.open(
+            exposed.features,
+            &wgpu_types::Limits::default(),
+            &wgpu_types::MemoryHints::default(),
+        )
+    }
+    .expect("failed to open device");
+    let device = open_device.device;
+    let queue = open_device.queue;
+
+    const SIZE: wgpu_types::BufferAddress = 256;
+    let buffer = unsafe {
+        device.create_buffer(&wgpu_hal::BufferDescriptor {
+            label: Some("audit-smoke buffer"),
+            size: SIZE,
+            usage: wgpu_types::BufferUses::MAP_WRITE
+                | wgpu_types::BufferUses::MAP_READ
+                | wgpu_types::BufferUses::COPY_SRC
+                | wgpu_types::BufferUses::COPY_DST,
+            memory_flags: wgpu_hal::MemoryFlags::empty(),
+        })
+    }
+    .expect("failed to create buffer");
+
+    unsafe {
+        let mapping = device
+            .map_buffer(&*buffer, 0..SIZE)
+            .expect("failed to map buffer");
+        core::ptr::write_bytes(mapping.ptr.as_ptr(), 0x42, SIZE as usize);
+        #[allow(clippy::single_range_in_vec_init)]
+        device.flush_mapped_ranges(&*buffer, &[0..SIZE]);
+        device.unmap_buffer(&*buffer);
+    }
+    println!("Wrote {SIZE} bytes to a mapped buffer");
+
+    let mut encoder = unsafe {
+        device.create_command_encoder(&wgpu_hal::CommandEncoderDescriptor {
+            label: Some("audit-smoke encoder"),
+            queue: &*queue,
+        })
+    }
+    .expect("failed to create command encoder");
+
+    let command_buffer = unsafe {
+        encoder
+            .begin_encoding(Some("audit-smoke pass"))
+            .expect("failed to begin encoding");
+        encoder.end_encoding().expect("failed to end encoding")
+    };
+
+    let fence = unsafe { device.create_fence() }.expect("failed to create fence");
+    unsafe {
+        queue
+            .submit(&[&*command_buffer], &[], (&*fence, 1))
+            .expect("submit failed");
+        device.wait(&*fence, 1, None).expect("wait failed");
+    }
+    println!("Submitted and waited on an empty command buffer");
+
+    unsafe {
+        encoder.reset_all(vec![command_buffer]);
+        device.destroy_fence(fence);
+        device.destroy_buffer(buffer);
+    }
+
+    println!("audit smoke test completed successfully");
+}

wgpu-hal/src/audit/adapter.rs

@@ -12,45 +12,35 @@ impl crate::Adapter for super::Adapter {
     ) -> Result<crate::OpenDevice<super::Api>, crate::DeviceError> {
         let crate::DynOpenDevice { device, queue } =
             unsafe { self.inner.open(features, limits, memory_hints)? };
-        let device_id = self.shared.new_id();
-        let queue_id = self.shared.new_id();
         Ok(crate::OpenDevice {
-            device: super::Device {
-                inner: device,
-                id: device_id,
-                shared: self.shared.clone(),
-            },
-            queue: super::Queue {
-                inner: queue,
-                id: queue_id,
-                shared: self.shared.clone(),
-            },
+            device: super::Device::wrap(device, self.shared.clone()),
+            queue: super::Queue::wrap(queue, self.shared.clone()),
         })
     }
 
     unsafe fn texture_format_capabilities(
         &self,
         format: wgt::TextureFormat,
     ) -> crate::TextureFormatCapabilities {
-        todo!()
+        unsafe { self.inner.texture_format_capabilities(format) }
     }
 
     unsafe fn surface_capabilities(
         &self,
         surface: &<super::Api as crate::Api>::Surface,
     ) -> Option<crate::SurfaceCapabilities> {
-        todo!()
+        unsafe { self.inner.surface_capabilities(surface.as_dyn()) }
     }
 
     unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp {
-        todo!()
+        unsafe { self.inner.get_presentation_timestamp() }
     }
 
     fn get_ordered_buffer_usages(&self) -> wgt::BufferUses {
-        todo!()
+        self.inner.get_ordered_buffer_usages()
     }
 
     fn get_ordered_texture_usages(&self) -> wgt::TextureUses {
-        todo!()
+        self.inner.get_ordered_texture_usages()
     }
 }