Move out invalidity from the Registry

deno_webgpu/lib.rs

@@ -414,9 +414,9 @@ pub fn op_webgpu_request_adapter(
             })
         }
     };
-    let adapter_features = instance.adapter_features(adapter)?;
+    let adapter_features = instance.adapter_features(adapter);
     let features = deserialize_features(&adapter_features);
-    let adapter_limits = instance.adapter_limits(adapter)?;
+    let adapter_limits = instance.adapter_limits(adapter);
 
     let instance = instance.clone();
 
@@ -649,7 +649,7 @@ pub fn op_webgpu_request_device(
         memory_hints: wgpu_types::MemoryHints::default(),
     };
 
-    let (device, queue, maybe_err) = instance.adapter_request_device(
+    let res = instance.adapter_request_device(
         adapter,
         &descriptor,
         std::env::var("DENO_WEBGPU_TRACE")
@@ -660,13 +660,12 @@ pub fn op_webgpu_request_device(
         None,
     );
     adapter_resource.close();
-    if let Some(err) = maybe_err {
-        return Err(DomExceptionOperationError::new(&err.to_string()).into());
-    }
 
-    let device_features = instance.device_features(device)?;
+    let (device, queue) = res.map_err(|err| DomExceptionOperationError::new(&err.to_string()))?;
+
+    let device_features = instance.device_features(device);
     let features = deserialize_features(&device_features);
-    let limits = instance.device_limits(device)?;
+    let limits = instance.device_limits(device);
 
     let instance = instance.clone();
     let instance2 = instance.clone();
@@ -705,7 +704,7 @@ pub fn op_webgpu_request_adapter_info(
     let adapter = adapter_resource.1;
     let instance = state.borrow::<Instance>();
 
-    let info = instance.adapter_get_info(adapter)?;
+    let info = instance.adapter_get_info(adapter);
     adapter_resource.close();
 
     Ok(GPUAdapterInfo {

player/src/bin/play.rs

@@ -78,18 +78,18 @@ fn main() {
                 )
                 .expect("Unable to find an adapter for selected backend");
 
-            let info = global.adapter_get_info(adapter).unwrap();
+            let info = global.adapter_get_info(adapter);
             log::info!("Picked '{}'", info.name);
             let device_id = wgc::id::Id::zip(1, 0, backend);
             let queue_id = wgc::id::Id::zip(1, 0, backend);
-            let (_, _, error) = global.adapter_request_device(
+            let res = global.adapter_request_device(
                 adapter,
                 &desc,
                 None,
                 Some(device_id),
                 Some(queue_id),
             );
-            if let Some(e) = error {
+            if let Err(e) = res {
                 panic!("{:?}", e);
             }
             (device_id, queue_id)

player/tests/test.rs

@@ -108,7 +108,7 @@ impl Test<'_> {
         let backend = adapter.backend();
         let device_id = wgc::id::Id::zip(test_num, 0, backend);
         let queue_id = wgc::id::Id::zip(test_num, 0, backend);
-        let (_, _, error) = global.adapter_request_device(
+        let res = global.adapter_request_device(
             adapter,
             &wgt::DeviceDescriptor {
                 label: None,
@@ -120,7 +120,7 @@ impl Test<'_> {
             Some(device_id),
             Some(queue_id),
         );
-        if let Some(e) = error {
+        if let Err(e) = res {
             panic!("{:?}", e);
         }
 
@@ -244,8 +244,8 @@ impl Corpus {
                 };
 
                 println!("\tBackend {:?}", backend);
-                let supported_features = global.adapter_features(adapter).unwrap();
-                let downlevel_caps = global.adapter_downlevel_capabilities(adapter).unwrap();
+                let supported_features = global.adapter_features(adapter);
+                let downlevel_caps = global.adapter_downlevel_capabilities(adapter);
 
                 let test = Test::load(dir.join(test_path), adapter.backend());
                 if !supported_features.contains(test.features) {

tests/tests/device.rs

@@ -651,33 +651,6 @@ static DEVICE_DROP_THEN_LOST: GpuTestConfiguration = GpuTestConfiguration::new()
         );
     });
 
-#[gpu_test]
-static DEVICE_INVALID_THEN_SET_LOST_CALLBACK: GpuTestConfiguration = GpuTestConfiguration::new()
-    .parameters(TestParameters::default().expect_fail(FailureCase::webgl2()))
-    .run_sync(|ctx| {
-        // This test checks that when the device is invalid, a subsequent call
-        // to set the device lost callback will immediately call the callback.
-        // Invalidating the device is done via a testing-only method. Fails on
-        // webgl because webgl doesn't implement make_invalid.
-
-        // Make the device invalid.
-        ctx.device.make_invalid();
-
-        static WAS_CALLED: AtomicBool = AtomicBool::new(false);
-
-        // Set a LoseDeviceCallback on the device.
-        let callback = Box::new(|reason, _m| {
-            WAS_CALLED.store(true, std::sync::atomic::Ordering::SeqCst);
-            assert_eq!(reason, wgt::DeviceLostReason::DeviceInvalid);
-        });
-        ctx.device.set_device_lost_callback(callback);
-
-        assert!(
-            WAS_CALLED.load(std::sync::atomic::Ordering::SeqCst),
-            "Device lost callback should have been called."
-        );
-    });
-
 #[gpu_test]
 static DEVICE_LOST_REPLACED_CALLBACK: GpuTestConfiguration = GpuTestConfiguration::new()
     .parameters(TestParameters::default())

tests/tests/pipeline.rs

@@ -8,7 +8,7 @@ static PIPELINE_DEFAULT_LAYOUT_BAD_MODULE: GpuTestConfiguration = GpuTestConfigu
     .parameters(
         TestParameters::default()
             // https://github.com/gfx-rs/wgpu/issues/4167
-            .expect_fail(FailureCase::always().panic("Pipeline is invalid")),
+            .expect_fail(FailureCase::always().panic("Error reflecting bind group")),
     )
     .run_sync(|ctx| {
         ctx.device.push_error_scope(wgpu::ErrorFilter::Validation);

tests/tests/resource_error.rs

@@ -17,21 +17,16 @@ static BAD_BUFFER: GpuTestConfiguration = GpuTestConfiguration::new().run_sync(|
         Some("`map` usage can only be combined with the opposite `copy`"),
     );
 
-    let error = match ctx.adapter_info.backend.to_str() {
-        "vulkan" | "vk" => "bufferid id(0,1,vk) is invalid",
-        "dx12" | "d3d12" => "bufferid id(0,1,d3d12) is invalid",
-        "metal" | "mtl" => "bufferid id(0,1,mtl) is invalid",
-        "opengl" | "gles" | "gl" => "bufferid id(0,1,gl) is invalid",
-        "webgpu" => "bufferid id(0,1,webgpu) is invalid",
-        b => b,
-    };
-
     fail(
         &ctx.device,
         || buffer.slice(..).map_async(wgpu::MapMode::Write, |_| {}),
-        Some(error),
+        Some("Buffer with '' label is invalid"),
+    );
+    fail(
+        &ctx.device,
+        || buffer.unmap(),
+        Some("Buffer with '' label is invalid"),
     );
-    fail(&ctx.device, || buffer.unmap(), Some(error));
     valid(&ctx.device, || buffer.destroy());
     valid(&ctx.device, || buffer.destroy());
 });
@@ -59,21 +54,12 @@ static BAD_TEXTURE: GpuTestConfiguration = GpuTestConfiguration::new().run_sync(
         Some("dimension x is zero"),
     );
 
-    let error = match ctx.adapter_info.backend.to_str() {
-        "vulkan" | "vk" => "textureid id(0,1,vk) is invalid",
-        "dx12" | "d3d12" => "textureid id(0,1,d3d12) is invalid",
-        "metal" | "mtl" => "textureid id(0,1,mtl) is invalid",
-        "opengl" | "gles" | "gl" => "textureid id(0,1,gl) is invalid",
-        "webgpu" => "textureid id(0,1,webgpu) is invalid",
-        b => b,
-    };
-
     fail(
         &ctx.device,
         || {
             let _ = texture.create_view(&wgpu::TextureViewDescriptor::default());
         },
-        Some(error),
+        Some("Texture with '' label is invalid"),
     );
     valid(&ctx.device, || texture.destroy());
     valid(&ctx.device, || texture.destroy());

wgpu-core/src/binding_model.rs

@@ -6,8 +6,8 @@ use crate::{
     init_tracker::{BufferInitTrackerAction, TextureInitTrackerAction},
     pipeline::{ComputePipeline, RenderPipeline},
     resource::{
-        Buffer, DestroyedResourceError, Labeled, MissingBufferUsageError, MissingTextureUsageError,
-        ResourceErrorIdent, Sampler, TextureView, TrackingData,
+        Buffer, DestroyedResourceError, InvalidResourceError, Labeled, MissingBufferUsageError,
+        MissingTextureUsageError, ResourceErrorIdent, Sampler, TextureView, TrackingData,
     },
     resource_log,
     snatch::{SnatchGuard, Snatchable},
@@ -79,14 +79,6 @@ pub enum CreateBindGroupLayoutError {
 pub enum CreateBindGroupError {
     #[error(transparent)]
     Device(#[from] DeviceError),
-    #[error("Bind group layout is invalid")]
-    InvalidLayout,
-    #[error("BufferId {0:?} is invalid")]
-    InvalidBufferId(BufferId),
-    #[error("TextureViewId {0:?} is invalid")]
-    InvalidTextureViewId(TextureViewId),
-    #[error("SamplerId {0:?} is invalid")]
-    InvalidSamplerId(SamplerId),
     #[error(transparent)]
     DestroyedResource(#[from] DestroyedResourceError),
     #[error(
@@ -188,6 +180,8 @@ pub enum CreateBindGroupError {
     StorageReadNotSupported(wgt::TextureFormat),
     #[error(transparent)]
     ResourceUsageCompatibility(#[from] ResourceUsageCompatibilityError),
+    #[error(transparent)]
+    InvalidResource(#[from] InvalidResourceError),
 }
 
 #[derive(Clone, Debug, Error)]
@@ -545,8 +539,6 @@ impl BindGroupLayout {
 pub enum CreatePipelineLayoutError {
     #[error(transparent)]
     Device(#[from] DeviceError),
-    #[error("BindGroupLayoutId {0:?} is invalid")]
-    InvalidBindGroupLayoutId(BindGroupLayoutId),
     #[error(
         "Push constant at index {index} has range bound {bound} not aligned to {}",
         wgt::PUSH_CONSTANT_ALIGNMENT
@@ -570,6 +562,8 @@ pub enum CreatePipelineLayoutError {
     TooManyBindings(BindingTypeMaxCountError),
     #[error("Bind group layout count {actual} exceeds device bind group limit {max}")]
     TooManyGroups { actual: usize, max: usize },
+    #[error(transparent)]
+    InvalidResource(#[from] InvalidResourceError),
 }
 
 #[derive(Clone, Debug, Error)]
@@ -1003,10 +997,10 @@ crate::impl_trackable!(BindGroup);
 #[derive(Clone, Debug, Error)]
 #[non_exhaustive]
 pub enum GetBindGroupLayoutError {
-    #[error("Pipeline is invalid")]
-    InvalidPipeline,
     #[error("Invalid group index {0}")]
     InvalidGroupIndex(u32),
+    #[error(transparent)]
+    InvalidResource(#[from] InvalidResourceError),
 }
 
 #[derive(Clone, Debug, Error, Eq, PartialEq)]

wgpu-core/src/command/bundle.rs

@@ -92,7 +92,10 @@ use crate::{
     id,
     init_tracker::{BufferInitTrackerAction, MemoryInitKind, TextureInitTrackerAction},
     pipeline::{PipelineFlags, RenderPipeline, VertexStep},
-    resource::{Buffer, DestroyedResourceError, Labeled, ParentDevice, TrackingData},
+    resource::{
+        Buffer, DestroyedResourceError, Fallible, InvalidResourceError, Labeled, ParentDevice,
+        TrackingData,
+    },
     resource_log,
     snatch::SnatchGuard,
     track::RenderBundleScope,
@@ -578,7 +581,7 @@ impl RenderBundleEncoder {
 
 fn set_bind_group(
     state: &mut State,
-    bind_group_guard: &crate::lock::RwLockReadGuard<crate::storage::Storage<BindGroup>>,
+    bind_group_guard: &crate::storage::Storage<Fallible<BindGroup>>,
     dynamic_offsets: &[u32],
     index: u32,
     num_dynamic_offsets: usize,
@@ -591,9 +594,7 @@ fn set_bind_group(
 
     let bind_group_id = bind_group_id.unwrap();
 
-    let bind_group = bind_group_guard
-        .get_owned(bind_group_id)
-        .map_err(|_| RenderCommandError::InvalidBindGroupId(bind_group_id))?;
+    let bind_group = bind_group_guard.get(bind_group_id).get()?;
 
     bind_group.same_device(&state.device)?;
 
@@ -630,15 +631,13 @@ fn set_bind_group(
 
 fn set_pipeline(
     state: &mut State,
-    pipeline_guard: &crate::lock::RwLockReadGuard<crate::storage::Storage<RenderPipeline>>,
+    pipeline_guard: &crate::storage::Storage<Fallible<RenderPipeline>>,
     context: &RenderPassContext,
     is_depth_read_only: bool,
     is_stencil_read_only: bool,
     pipeline_id: id::Id<id::markers::RenderPipeline>,
 ) -> Result<(), RenderBundleErrorInner> {
-    let pipeline = pipeline_guard
-        .get_owned(pipeline_id)
-        .map_err(|_| RenderCommandError::InvalidPipelineId(pipeline_id))?;
+    let pipeline = pipeline_guard.get(pipeline_id).get()?;
 
     pipeline.same_device(&state.device)?;
 
@@ -673,15 +672,13 @@ fn set_pipeline(
 
 fn set_index_buffer(
     state: &mut State,
-    buffer_guard: &crate::lock::RwLockReadGuard<crate::storage::Storage<Buffer>>,
+    buffer_guard: &crate::storage::Storage<Fallible<Buffer>>,
     buffer_id: id::Id<id::markers::Buffer>,
     index_format: wgt::IndexFormat,
     offset: u64,
     size: Option<std::num::NonZeroU64>,
 ) -> Result<(), RenderBundleErrorInner> {
-    let buffer = buffer_guard
-        .get_owned(buffer_id)
-        .map_err(|_| RenderCommandError::InvalidBufferId(buffer_id))?;
+    let buffer = buffer_guard.get(buffer_id).get()?;
 
     state
         .trackers
@@ -708,7 +705,7 @@ fn set_index_buffer(
 
 fn set_vertex_buffer(
     state: &mut State,
-    buffer_guard: &crate::lock::RwLockReadGuard<crate::storage::Storage<Buffer>>,
+    buffer_guard: &crate::storage::Storage<Fallible<Buffer>>,
     slot: u32,
     buffer_id: id::Id<id::markers::Buffer>,
     offset: u64,
@@ -723,9 +720,7 @@ fn set_vertex_buffer(
         .into());
     }
 
-    let buffer = buffer_guard
-        .get_owned(buffer_id)
-        .map_err(|_| RenderCommandError::InvalidBufferId(buffer_id))?;
+    let buffer = buffer_guard.get(buffer_id).get()?;
 
     state
         .trackers
@@ -852,7 +847,7 @@ fn draw_indexed(
 fn multi_draw_indirect(
     state: &mut State,
     dynamic_offsets: &[u32],
-    buffer_guard: &crate::lock::RwLockReadGuard<crate::storage::Storage<Buffer>>,
+    buffer_guard: &crate::storage::Storage<Fallible<Buffer>>,
     buffer_id: id::Id<id::markers::Buffer>,
     offset: u64,
     indexed: bool,
@@ -864,9 +859,7 @@ fn multi_draw_indirect(
     let pipeline = state.pipeline()?;
     let used_bind_groups = pipeline.used_bind_groups;
 
-    let buffer = buffer_guard
-        .get_owned(buffer_id)
-        .map_err(|_| RenderCommandError::InvalidBufferId(buffer_id))?;
+    let buffer = buffer_guard.get(buffer_id).get()?;
 
     state
         .trackers
@@ -1538,6 +1531,8 @@ pub(super) enum RenderBundleErrorInner {
     MissingDownlevelFlags(#[from] MissingDownlevelFlags),
     #[error(transparent)]
     Bind(#[from] BindError),
+    #[error(transparent)]
+    InvalidResource(#[from] InvalidResourceError),
 }
 
 impl<T> From<T> for RenderBundleErrorInner