Add DestroyedResourceError as a possible result from Fallible::get

wgpu-core/src/binding_model.rs

@@ -25,9 +25,9 @@ use crate::{
     init_tracker::{BufferInitTrackerAction, TextureInitTrackerAction},
     pipeline::{ComputePipeline, RenderPipeline},
     resource::{
-        Buffer, DestroyedResourceError, ExternalTexture, InvalidResourceError, Labeled,
-        MissingBufferUsageError, MissingTextureUsageError, RawResourceAccess, ResourceErrorIdent,
-        Sampler, TextureView, Tlas, TrackingData,
+        impl_resource_errors, Buffer, DestroyedResourceError, ExternalTexture,
+        InvalidResourceError, Labeled, MissingBufferUsageError, MissingTextureUsageError,
+        RawResourceAccess, ResourceErrorIdent, Sampler, TextureView, Tlas, TrackingData,
     },
     resource_log,
     snatch::{SnatchGuard, Snatchable},
@@ -134,7 +134,9 @@ pub enum CreateBindGroupError {
     #[error(transparent)]
     Device(#[from] DeviceError),
     #[error(transparent)]
-    DestroyedResource(#[from] DestroyedResourceError),
+    InvalidResource(InvalidResourceError),
+    #[error(transparent)]
+    DestroyedResource(DestroyedResourceError),
     #[error(transparent)]
     BindingError(#[from] BindingError),
     #[error(
@@ -254,10 +256,10 @@ pub enum CreateBindGroupError {
     StorageReadWriteNotSupported(wgt::TextureFormat),
     #[error(transparent)]
     ResourceUsageCompatibility(#[from] ResourceUsageCompatibilityError),
-    #[error(transparent)]
-    InvalidResource(#[from] InvalidResourceError),
 }
 
+impl_resource_errors!(CreateBindGroupError);
+
 impl WebGpuError for CreateBindGroupError {
     fn webgpu_error_type(&self) -> ErrorType {
         let e: &dyn WebGpuError = match self {
@@ -800,15 +802,20 @@ pub enum CreatePipelineLayoutError {
     #[error("Bind group layout count {actual} exceeds device bind group limit {max}")]
     TooManyGroups { actual: usize, max: usize },
     #[error(transparent)]
-    InvalidResource(#[from] InvalidResourceError),
+    InvalidResource(InvalidResourceError),
+    #[error(transparent)]
+    DestroyedResource(DestroyedResourceError),
 }
 
+impl_resource_errors!(CreatePipelineLayoutError);
+
 impl WebGpuError for CreatePipelineLayoutError {
     fn webgpu_error_type(&self) -> ErrorType {
         let e: &dyn WebGpuError = match self {
             Self::Device(e) => e,
             Self::MissingFeatures(e) => e,
             Self::InvalidResource(e) => e,
+            Self::DestroyedResource(e) => e,
             Self::TooManyBindings(e) => e,
             Self::MisalignedPushConstantRange { .. }
             | Self::MoreThanOnePushConstantRangePerStage { .. }
@@ -1275,14 +1282,19 @@ pub enum GetBindGroupLayoutError {
     #[error("Invalid group index {0}")]
     InvalidGroupIndex(u32),
     #[error(transparent)]
-    InvalidResource(#[from] InvalidResourceError),
+    InvalidResource(InvalidResourceError),
+    #[error(transparent)]
+    DestroyedResource(DestroyedResourceError),
 }
 
+impl_resource_errors!(GetBindGroupLayoutError);
+
 impl WebGpuError for GetBindGroupLayoutError {
     fn webgpu_error_type(&self) -> ErrorType {
         match self {
             Self::InvalidGroupIndex(_) => ErrorType::Validation,
             Self::InvalidResource(e) => e.webgpu_error_type(),
+            Self::DestroyedResource(e) => e.webgpu_error_type(),
         }
     }
 }

wgpu-core/src/command/bundle.rs

@@ -111,8 +111,8 @@ use crate::{
     init_tracker::{BufferInitTrackerAction, MemoryInitKind, TextureInitTrackerAction},
     pipeline::{PipelineFlags, RenderPipeline, VertexStep},
     resource::{
-        Buffer, DestroyedResourceError, Fallible, InvalidResourceError, Labeled, ParentDevice,
-        RawResourceAccess, TrackingData,
+        Buffer, DestroyedResourceError, Fallible, Labeled, ParentDevice, RawResourceAccess,
+        TrackingData,
     },
     resource_log,
     snatch::SnatchGuard,
@@ -1601,8 +1601,6 @@ pub(super) enum RenderBundleErrorInner {
     MissingDownlevelFlags(#[from] MissingDownlevelFlags),
     #[error(transparent)]
     Bind(#[from] BindError),
-    #[error(transparent)]
-    InvalidResource(#[from] InvalidResourceError),
 }
 
 impl<T> From<T> for RenderBundleErrorInner
@@ -1632,7 +1630,6 @@ impl WebGpuError for RenderBundleError {
             RenderBundleErrorInner::Draw(e) => e,
             RenderBundleErrorInner::MissingDownlevelFlags(e) => e,
             RenderBundleErrorInner::Bind(e) => e,
-            RenderBundleErrorInner::InvalidResource(e) => e,
         };
         e.webgpu_error_type()
     }

wgpu-core/src/command/clear.rs

@@ -13,8 +13,9 @@ use crate::{
     id::{BufferId, CommandEncoderId, TextureId},
     init_tracker::{MemoryInitKind, TextureInitRange},
     resource::{
-        DestroyedResourceError, InvalidResourceError, Labeled, MissingBufferUsageError,
-        ParentDevice, RawResourceAccess, ResourceErrorIdent, Texture, TextureClearMode,
+        impl_resource_errors, DestroyedResourceError, InvalidResourceError, Labeled,
+        MissingBufferUsageError, ParentDevice, RawResourceAccess, ResourceErrorIdent, Texture,
+        TextureClearMode,
     },
     snatch::SnatchGuard,
     track::TextureTrackerSetSingle,
@@ -31,8 +32,6 @@ use wgt::{
 #[derive(Clone, Debug, Error)]
 #[non_exhaustive]
 pub enum ClearError {
-    #[error(transparent)]
-    DestroyedResource(#[from] DestroyedResourceError),
     #[error(transparent)]
     MissingFeatures(#[from] MissingFeatures),
     #[error("{0} can not be cleared")]
@@ -78,9 +77,13 @@ whereas subesource range specified start {subresource_base_array_layer} and coun
     #[error(transparent)]
     EncoderState(#[from] EncoderStateError),
     #[error(transparent)]
-    InvalidResource(#[from] InvalidResourceError),
+    InvalidResource(InvalidResourceError),
+    #[error(transparent)]
+    DestroyedResource(DestroyedResourceError),
 }
 
+impl_resource_errors!(ClearError);
+
 impl WebGpuError for ClearError {
     fn webgpu_error_type(&self) -> ErrorType {
         let e: &dyn WebGpuError = match self {

wgpu-core/src/command/compute.rs

@@ -7,9 +7,6 @@ use wgt::{
 use alloc::{borrow::Cow, boxed::Box, sync::Arc, vec::Vec};
 use core::{fmt, str};
 
-use crate::command::{
-    pass, CommandEncoder, DebugGroupError, EncoderStateError, PassStateError, TimestampWritesError,
-};
 use crate::resource::DestroyedResourceError;
 use crate::{binding_model::BindError, resource::RawResourceAccess};
 use crate::{
@@ -34,6 +31,13 @@ use crate::{
     track::{ResourceUsageCompatibilityError, Tracker, TrackerIndex},
     Label,
 };
+use crate::{
+    command::{
+        pass, CommandEncoder, DebugGroupError, EncoderStateError, PassStateError,
+        TimestampWritesError,
+    },
+    resource::impl_resource_errors,
+};
 
 pub type ComputeBasePass = BasePass<ArcComputeCommand, ComputePassError>;
 
@@ -150,7 +154,9 @@ pub enum ComputePassErrorInner {
     #[error(transparent)]
     BindGroupIndexOutOfRange(#[from] pass::BindGroupIndexOutOfRange),
     #[error(transparent)]
-    DestroyedResource(#[from] DestroyedResourceError),
+    InvalidResource(InvalidResourceError),
+    #[error(transparent)]
+    DestroyedResource(DestroyedResourceError),
     #[error("Indirect buffer offset {0:?} is not a multiple of 4")]
     UnalignedIndirectBufferOffset(BufferAddress),
     #[error("Indirect buffer uses bytes {offset}..{end_offset} which overruns indirect buffer of size {buffer_size}")]
@@ -184,14 +190,14 @@ pub enum ComputePassErrorInner {
     #[error("The compute pass has already been ended and no further commands can be recorded")]
     PassEnded,
     #[error(transparent)]
-    InvalidResource(#[from] InvalidResourceError),
-    #[error(transparent)]
     TimestampWrites(#[from] TimestampWritesError),
     // This one is unreachable, but required for generic pass support
     #[error(transparent)]
     InvalidValuesOffset(#[from] pass::InvalidValuesOffset),
 }
 
+impl_resource_errors!(ComputePassErrorInner);
+
 /// Error encountered when performing a compute pass, stored for later reporting
 /// when encoding ends.
 #[derive(Clone, Debug, Error)]

wgpu-core/src/command/draw.rs

@@ -6,6 +6,7 @@ use wgt::error::{ErrorType, WebGpuError};
 
 use super::bind::BinderError;
 use crate::command::pass;
+use crate::resource::{impl_resource_errors, InvalidResourceError};
 use crate::{
     binding_model::{BindingError, LateMinBufferBindingSizeMismatch, PushConstantUploadError},
     resource::{
@@ -103,7 +104,9 @@ pub enum RenderCommandError {
     #[error(transparent)]
     ResourceUsageCompatibility(#[from] ResourceUsageCompatibilityError),
     #[error(transparent)]
-    DestroyedResource(#[from] DestroyedResourceError),
+    InvalidResource(InvalidResourceError),
+    #[error(transparent)]
+    DestroyedResource(DestroyedResourceError),
     #[error(transparent)]
     MissingBufferUsage(#[from] MissingBufferUsageError),
     #[error(transparent)]
@@ -124,11 +127,14 @@ pub enum RenderCommandError {
     Unimplemented(&'static str),
 }
 
+impl_resource_errors!(RenderCommandError);
+
 impl WebGpuError for RenderCommandError {
     fn webgpu_error_type(&self) -> ErrorType {
         let e: &dyn WebGpuError = match self {
             Self::IncompatiblePipelineTargets(e) => e,
             Self::ResourceUsageCompatibility(e) => e,
+            Self::InvalidResource(e) => e,
             Self::DestroyedResource(e) => e,
             Self::MissingBufferUsage(e) => e,
             Self::MissingTextureUsage(e) => e,

wgpu-core/src/command/mod.rs

@@ -41,7 +41,8 @@ use crate::snatch::SnatchGuard;
 use crate::init_tracker::BufferInitTrackerAction;
 use crate::ray_tracing::{AsAction, BuildAccelerationStructureError};
 use crate::resource::{
-    DestroyedResourceError, Fallible, InvalidResourceError, Labeled, ParentDevice as _, QuerySet,
+    impl_resource_errors, BadResourceError, DestroyedResourceError, Fallible, InvalidResourceError,
+    Labeled, ParentDevice as _, QuerySet,
 };
 use crate::storage::Storage;
 use crate::track::{DeviceTracker, ResourceUsageCompatibilityError, Tracker, UsageScope};
@@ -1042,9 +1043,9 @@ pub enum CommandEncoderError {
     #[error(transparent)]
     Device(#[from] DeviceError),
     #[error(transparent)]
-    InvalidResource(#[from] InvalidResourceError),
+    InvalidResource(InvalidResourceError),
     #[error(transparent)]
-    DestroyedResource(#[from] DestroyedResourceError),
+    DestroyedResource(DestroyedResourceError),
     #[error(transparent)]
     ResourceUsage(#[from] ResourceUsageCompatibilityError),
     #[error(transparent)]
@@ -1067,6 +1068,8 @@ pub enum CommandEncoderError {
     RenderPass(#[from] RenderPassError),
 }
 
+impl_resource_errors!(CommandEncoderError);
+
 impl CommandEncoderError {
     fn is_destroyed_error(&self) -> bool {
         matches!(
@@ -1310,7 +1313,7 @@ impl Global {
             + From<QueryUseError>
             + From<DeviceError>
             + From<MissingFeatures>
-            + From<InvalidResourceError>,
+            + From<BadResourceError>,
     {
         let &PassTimestampWrites {
             query_set,

wgpu-core/src/command/query.rs

@@ -10,8 +10,8 @@ use crate::{
     id,
     init_tracker::MemoryInitKind,
     resource::{
-        DestroyedResourceError, InvalidResourceError, MissingBufferUsageError, ParentDevice,
-        QuerySet, RawResourceAccess, Trackable,
+        impl_resource_errors, DestroyedResourceError, InvalidResourceError,
+        MissingBufferUsageError, ParentDevice, QuerySet, RawResourceAccess, Trackable,
     },
     track::{StatelessTracker, TrackerIndex},
     FastHashMap,
@@ -107,11 +107,13 @@ pub enum QueryError {
     #[error("Error encountered while trying to resolve a query")]
     Resolve(#[from] ResolveError),
     #[error(transparent)]
-    DestroyedResource(#[from] DestroyedResourceError),
+    DestroyedResource(DestroyedResourceError),
     #[error(transparent)]
-    InvalidResource(#[from] InvalidResourceError),
+    InvalidResource(InvalidResourceError),
 }
 
+impl_resource_errors!(QueryError);
+
 impl WebGpuError for QueryError {
     fn webgpu_error_type(&self) -> ErrorType {
         let e: &dyn WebGpuError = match self {

wgpu-core/src/command/render.rs

@@ -9,11 +9,6 @@ use wgt::{
     TextureSelector, TextureUsages, TextureViewDimension, VertexStepMode,
 };
 
-use crate::command::{
-    pass, pass_base, pass_try, validate_and_begin_occlusion_query,
-    validate_and_begin_pipeline_statistics_query, DebugGroupError, EncoderStateError,
-    InnerCommandEncoder, PassStateError, TimestampWritesError,
-};
 use crate::pipeline::{RenderPipeline, VertexStep};
 use crate::resource::RawResourceAccess;
 use crate::resource::{InvalidResourceError, ResourceErrorIdent};
@@ -37,12 +32,21 @@ use crate::{
     init_tracker::{MemoryInitKind, TextureInitRange, TextureInitTrackerAction},
     pipeline::PipelineFlags,
     resource::{
-        DestroyedResourceError, Labeled, MissingBufferUsageError, MissingTextureUsageError,
-        ParentDevice, QuerySet, Texture, TextureView, TextureViewNotRenderableReason,
+        impl_resource_errors, DestroyedResourceError, Labeled, MissingBufferUsageError,
+        MissingTextureUsageError, ParentDevice, QuerySet, Texture, TextureView,
+        TextureViewNotRenderableReason,
     },
     track::{ResourceUsageCompatibilityError, Tracker, UsageScope},
     Label,
 };
+use crate::{
+    command::{
+        pass, pass_base, pass_try, validate_and_begin_occlusion_query,
+        validate_and_begin_pipeline_statistics_query, DebugGroupError, EncoderStateError,
+        InnerCommandEncoder, PassStateError, TimestampWritesError,
+    },
+    resource::BadResourceError,
+};
 
 #[cfg(feature = "serde")]
 use serde::Deserialize;
@@ -778,15 +782,17 @@ pub enum RenderPassErrorInner {
     #[error("missing occlusion query set")]
     MissingOcclusionQuerySet,
     #[error(transparent)]
-    DestroyedResource(#[from] DestroyedResourceError),
+    DestroyedResource(DestroyedResourceError),
     #[error("The compute pass has already been ended and no further commands can be recorded")]
     PassEnded,
     #[error(transparent)]
-    InvalidResource(#[from] InvalidResourceError),
+    InvalidResource(InvalidResourceError),
     #[error(transparent)]
     TimestampWrites(#[from] TimestampWritesError),
 }
 
+impl_resource_errors!(RenderPassErrorInner);
+
 impl From<MissingBufferUsageError> for RenderPassErrorInner {
     fn from(error: MissingBufferUsageError) -> Self {
         Self::RenderCommand(error.into())
@@ -3079,7 +3085,7 @@ impl Global {
     fn resolve_render_pass_buffer_id(
         &self,
         buffer_id: id::Id<id::markers::Buffer>,
-    ) -> Result<Arc<crate::resource::Buffer>, InvalidResourceError> {
+    ) -> Result<Arc<crate::resource::Buffer>, BadResourceError> {
         let hub = &self.hub;
         let buffer = hub.buffers.get(buffer_id).get()?;
 
@@ -3089,7 +3095,7 @@ impl Global {
     fn resolve_render_pass_query_set(
         &self,
         query_set_id: id::Id<id::markers::QuerySet>,
-    ) -> Result<Arc<QuerySet>, InvalidResourceError> {
+    ) -> Result<Arc<QuerySet>, BadResourceError> {
         let hub = &self.hub;
         let query_set = hub.query_sets.get(query_set_id).get()?;
 

wgpu-core/src/device/queue.rs

@@ -33,8 +33,8 @@ use crate::{
     lock::{rank, Mutex, MutexGuard, RwLock, RwLockWriteGuard},
     ray_tracing::{BlasCompactReadyPendingClosure, CompactBlasError},
     resource::{
-        Blas, BlasCompactState, Buffer, BufferAccessError, BufferMapState, DestroyedBuffer,
-        DestroyedResourceError, DestroyedTexture, Fallible, FlushedStagingBuffer,
+        impl_resource_errors, Blas, BlasCompactState, Buffer, BufferAccessError, BufferMapState,
+        DestroyedBuffer, DestroyedResourceError, DestroyedTexture, Fallible, FlushedStagingBuffer,
         InvalidResourceError, Labeled, ParentDevice, ResourceErrorIdent, StagingBuffer, Texture,
         TextureInner, Trackable, TrackingData,
     },
@@ -462,11 +462,13 @@ pub enum QueueWriteError {
     #[error(transparent)]
     MemoryInitFailure(#[from] ClearError),
     #[error(transparent)]
-    DestroyedResource(#[from] DestroyedResourceError),
+    DestroyedResource(DestroyedResourceError),
     #[error(transparent)]
-    InvalidResource(#[from] InvalidResourceError),
+    InvalidResource(InvalidResourceError),
 }
 
+impl_resource_errors!(QueueWriteError);
+
 impl WebGpuError for QueueWriteError {
     fn webgpu_error_type(&self) -> ErrorType {
         let e: &dyn WebGpuError = match self {