Add WasmNotSendSync (#4702)

examples/common/src/framework.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use wgpu::{Instance, Surface, WasmNotSend, WasmNotSync};
+use wgpu::{Instance, Surface, WasmNotSendSync};
 use wgpu_test::GpuTestConfiguration;
 use winit::{
     dpi::PhysicalSize,
@@ -504,7 +504,7 @@ pub struct ExampleTestParams<E> {
     pub _phantom: std::marker::PhantomData<E>,
 }
 
-impl<E: Example + WasmNotSend + WasmNotSync> From<ExampleTestParams<E>> for GpuTestConfiguration {
+impl<E: Example + WasmNotSendSync> From<ExampleTestParams<E>> for GpuTestConfiguration {
     fn from(params: ExampleTestParams<E>) -> Self {
         GpuTestConfiguration::new()
             .name(params.name)

wgpu-hal/src/lib.rs

@@ -95,7 +95,7 @@ use std::{
 
 use bitflags::bitflags;
 use thiserror::Error;
-use wgt::{WasmNotSend, WasmNotSync};
+use wgt::WasmNotSendSync;
 
 // - Vertex + Fragment
 // - Compute
@@ -200,25 +200,25 @@ pub trait Api: Clone + fmt::Debug + Sized {
 
     type Queue: Queue<Self>;
     type CommandEncoder: CommandEncoder<Self>;
-    type CommandBuffer: WasmNotSend + WasmNotSync + fmt::Debug;
+    type CommandBuffer: WasmNotSendSync + fmt::Debug;
 
-    type Buffer: fmt::Debug + WasmNotSend + WasmNotSync + 'static;
-    type Texture: fmt::Debug + WasmNotSend + WasmNotSync + 'static;
-    type SurfaceTexture: fmt::Debug + WasmNotSend + WasmNotSync + Borrow<Self::Texture>;
-    type TextureView: fmt::Debug + WasmNotSend + WasmNotSync;
-    type Sampler: fmt::Debug + WasmNotSend + WasmNotSync;
-    type QuerySet: fmt::Debug + WasmNotSend + WasmNotSync;
-    type Fence: fmt::Debug + WasmNotSend + WasmNotSync;
+    type Buffer: fmt::Debug + WasmNotSendSync + 'static;
+    type Texture: fmt::Debug + WasmNotSendSync + 'static;
+    type SurfaceTexture: fmt::Debug + WasmNotSendSync + Borrow<Self::Texture>;
+    type TextureView: fmt::Debug + WasmNotSendSync;
+    type Sampler: fmt::Debug + WasmNotSendSync;
+    type QuerySet: fmt::Debug + WasmNotSendSync;
+    type Fence: fmt::Debug + WasmNotSendSync;
 
-    type BindGroupLayout: fmt::Debug + WasmNotSend + WasmNotSync;
-    type BindGroup: fmt::Debug + WasmNotSend + WasmNotSync;
-    type PipelineLayout: WasmNotSend + WasmNotSync;
-    type ShaderModule: fmt::Debug + WasmNotSend + WasmNotSync;
-    type RenderPipeline: WasmNotSend + WasmNotSync;
-    type ComputePipeline: WasmNotSend + WasmNotSync;
+    type BindGroupLayout: fmt::Debug + WasmNotSendSync;
+    type BindGroup: fmt::Debug + WasmNotSendSync;
+    type PipelineLayout: WasmNotSendSync;
+    type ShaderModule: fmt::Debug + WasmNotSendSync;
+    type RenderPipeline: WasmNotSendSync;
+    type ComputePipeline: WasmNotSendSync;
 }
 
-pub trait Instance<A: Api>: Sized + WasmNotSend + WasmNotSync {
+pub trait Instance<A: Api>: Sized + WasmNotSendSync {
     unsafe fn init(desc: &InstanceDescriptor) -> Result<Self, InstanceError>;
     unsafe fn create_surface(
         &self,
@@ -229,7 +229,7 @@ pub trait Instance<A: Api>: Sized + WasmNotSend + WasmNotSync {
     unsafe fn enumerate_adapters(&self) -> Vec<ExposedAdapter<A>>;
 }
 
-pub trait Surface<A: Api>: WasmNotSend + WasmNotSync {
+pub trait Surface<A: Api>: WasmNotSendSync {
     /// Configures the surface to use the given device.
     ///
     /// # Safety
@@ -271,7 +271,7 @@ pub trait Surface<A: Api>: WasmNotSend + WasmNotSync {
     unsafe fn discard_texture(&mut self, texture: A::SurfaceTexture);
 }
 
-pub trait Adapter<A: Api>: WasmNotSend + WasmNotSync {
+pub trait Adapter<A: Api>: WasmNotSendSync {
     unsafe fn open(
         &self,
         features: wgt::Features,
@@ -295,7 +295,7 @@ pub trait Adapter<A: Api>: WasmNotSend + WasmNotSync {
     unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp;
 }
 
-pub trait Device<A: Api>: WasmNotSend + WasmNotSync {
+pub trait Device<A: Api>: WasmNotSendSync {
     /// Exit connection to this logical device.
     unsafe fn exit(self, queue: A::Queue);
     /// Creates a new buffer.
@@ -391,7 +391,7 @@ pub trait Device<A: Api>: WasmNotSend + WasmNotSync {
     unsafe fn stop_capture(&self);
 }
 
-pub trait Queue<A: Api>: WasmNotSend + WasmNotSync {
+pub trait Queue<A: Api>: WasmNotSendSync {
     /// Submits the command buffers for execution on GPU.
     ///
     /// Valid usage:
@@ -415,7 +415,7 @@ pub trait Queue<A: Api>: WasmNotSend + WasmNotSync {
 /// Serves as a parent for all the encoded command buffers.
 /// Works in bursts of action: one or more command buffers are recorded,
 /// then submitted to a queue, and then it needs to be `reset_all()`.
-pub trait CommandEncoder<A: Api>: WasmNotSend + WasmNotSync + fmt::Debug {
+pub trait CommandEncoder<A: Api>: WasmNotSendSync + fmt::Debug {
     /// Begin encoding a new command buffer.
     unsafe fn begin_encoding(&mut self, label: Label) -> Result<(), DeviceError>;
     /// Discard currently recorded list, if any.

wgpu-types/src/lib.rs

@@ -6663,6 +6663,8 @@ pub use send_sync::*;
 
 #[doc(hidden)]
 mod send_sync {
+    pub trait WasmNotSendSync: WasmNotSend + WasmNotSync {}
+    impl<T: WasmNotSend + WasmNotSync> WasmNotSendSync for T {}
     #[cfg(any(
         not(target_arch = "wasm32"),
         all(

wgpu/src/backend/direct.rs

@@ -24,7 +24,7 @@ use std::{
 use wgc::command::{bundle_ffi::*, compute_ffi::*, render_ffi::*};
 use wgc::device::DeviceLostClosure;
 use wgc::id::TypedId;
-use wgt::{WasmNotSend, WasmNotSync};
+use wgt::WasmNotSendSync;
 
 const LABEL: &str = "label";
 
@@ -306,7 +306,7 @@ impl Context {
     fn handle_error(
         &self,
         sink_mutex: &Mutex<ErrorSinkRaw>,
-        cause: impl Error + WasmNotSend + WasmNotSync + 'static,
+        cause: impl Error + WasmNotSendSync + 'static,
         label_key: &'static str,
         label: Label,
         string: &'static str,
@@ -340,7 +340,7 @@ impl Context {
     fn handle_error_nolabel(
         &self,
         sink_mutex: &Mutex<ErrorSinkRaw>,
-        cause: impl Error + WasmNotSend + WasmNotSync + 'static,
+        cause: impl Error + WasmNotSendSync + 'static,
         string: &'static str,
     ) {
         self.handle_error(sink_mutex, cause, "", None, string)
@@ -349,7 +349,7 @@ impl Context {
     #[track_caller]
     fn handle_error_fatal(
         &self,
-        cause: impl Error + WasmNotSend + WasmNotSync + 'static,
+        cause: impl Error + WasmNotSendSync + 'static,
         operation: &'static str,
     ) -> ! {
         panic!("Error in {operation}: {f}", f = self.format_error(&cause));

wgpu/src/context.rs

@@ -4,7 +4,7 @@ use wgt::{
     strict_assert, strict_assert_eq, AdapterInfo, BufferAddress, BufferSize, Color,
     DeviceLostReason, DownlevelCapabilities, DynamicOffset, Extent3d, Features, ImageDataLayout,
     ImageSubresourceRange, IndexFormat, Limits, ShaderStages, SurfaceStatus, TextureFormat,
-    TextureFormatFeatures, WasmNotSend, WasmNotSync,
+    TextureFormatFeatures, WasmNotSend, WasmNotSendSync,
 };
 
 use crate::{
@@ -27,55 +27,55 @@ impl<T: Into<ObjectId> + From<ObjectId> + Debug + 'static> ContextId for T {}
 /// Meta trait for an data associated with an id tracked by a context.
 ///
 /// There is no need to manually implement this trait since there is a blanket implementation for this trait.
-pub trait ContextData: Debug + WasmNotSend + WasmNotSync + 'static {}
-impl<T: Debug + WasmNotSend + WasmNotSync + 'static> ContextData for T {}
+pub trait ContextData: Debug + WasmNotSendSync + 'static {}
+impl<T: Debug + WasmNotSendSync + 'static> ContextData for T {}
 
-pub trait Context: Debug + WasmNotSend + WasmNotSync + Sized {
-    type AdapterId: ContextId + WasmNotSend + WasmNotSync;
+pub trait Context: Debug + WasmNotSendSync + Sized {
+    type AdapterId: ContextId + WasmNotSendSync;
     type AdapterData: ContextData;
-    type DeviceId: ContextId + WasmNotSend + WasmNotSync;
+    type DeviceId: ContextId + WasmNotSendSync;
     type DeviceData: ContextData;
-    type QueueId: ContextId + WasmNotSend + WasmNotSync;
+    type QueueId: ContextId + WasmNotSendSync;
     type QueueData: ContextData;
-    type ShaderModuleId: ContextId + WasmNotSend + WasmNotSync;
+    type ShaderModuleId: ContextId + WasmNotSendSync;
     type ShaderModuleData: ContextData;
-    type BindGroupLayoutId: ContextId + WasmNotSend + WasmNotSync;
+    type BindGroupLayoutId: ContextId + WasmNotSendSync;
     type BindGroupLayoutData: ContextData;
-    type BindGroupId: ContextId + WasmNotSend + WasmNotSync;
+    type BindGroupId: ContextId + WasmNotSendSync;
     type BindGroupData: ContextData;
-    type TextureViewId: ContextId + WasmNotSend + WasmNotSync;
+    type TextureViewId: ContextId + WasmNotSendSync;
     type TextureViewData: ContextData;
-    type SamplerId: ContextId + WasmNotSend + WasmNotSync;
+    type SamplerId: ContextId + WasmNotSendSync;
     type SamplerData: ContextData;
-    type BufferId: ContextId + WasmNotSend + WasmNotSync;
+    type BufferId: ContextId + WasmNotSendSync;
     type BufferData: ContextData;
-    type TextureId: ContextId + WasmNotSend + WasmNotSync;
+    type TextureId: ContextId + WasmNotSendSync;
     type TextureData: ContextData;
-    type QuerySetId: ContextId + WasmNotSend + WasmNotSync;
+    type QuerySetId: ContextId + WasmNotSendSync;
     type QuerySetData: ContextData;
-    type PipelineLayoutId: ContextId + WasmNotSend + WasmNotSync;
+    type PipelineLayoutId: ContextId + WasmNotSendSync;
     type PipelineLayoutData: ContextData;
-    type RenderPipelineId: ContextId + WasmNotSend + WasmNotSync;
+    type RenderPipelineId: ContextId + WasmNotSendSync;
     type RenderPipelineData: ContextData;
-    type ComputePipelineId: ContextId + WasmNotSend + WasmNotSync;
+    type ComputePipelineId: ContextId + WasmNotSendSync;
     type ComputePipelineData: ContextData;
-    type CommandEncoderId: ContextId + WasmNotSend + WasmNotSync;
+    type CommandEncoderId: ContextId + WasmNotSendSync;
     type CommandEncoderData: ContextData;
     type ComputePassId: ContextId;
     type ComputePassData: ContextData;
     type RenderPassId: ContextId;
     type RenderPassData: ContextData;
-    type CommandBufferId: ContextId + WasmNotSend + WasmNotSync;
+    type CommandBufferId: ContextId + WasmNotSendSync;
     type CommandBufferData: ContextData;
     type RenderBundleEncoderId: ContextId;
     type RenderBundleEncoderData: ContextData;
-    type RenderBundleId: ContextId + WasmNotSend + WasmNotSync;
+    type RenderBundleId: ContextId + WasmNotSendSync;
     type RenderBundleData: ContextData;
-    type SurfaceId: ContextId + WasmNotSend + WasmNotSync;
+    type SurfaceId: ContextId + WasmNotSendSync;
     type SurfaceData: ContextData;
 
-    type SurfaceOutputDetail: WasmNotSend + WasmNotSync + 'static;
-    type SubmissionIndex: ContextId + Clone + Copy + WasmNotSend + WasmNotSync;
+    type SurfaceOutputDetail: WasmNotSendSync + 'static;
+    type SubmissionIndex: ContextId + Clone + Copy + WasmNotSendSync;
     type SubmissionIndexData: ContextData + Copy;
 
     type RequestAdapterFuture: Future<Output = Option<(Self::AdapterId, Self::AdapterData)>>
@@ -1082,15 +1082,13 @@ impl ObjectId {
 ))]
 static_assertions::assert_impl_all!(ObjectId: Send, Sync);
 
-pub(crate) fn downcast_ref<T: Debug + WasmNotSend + WasmNotSync + 'static>(
-    data: &crate::Data,
-) -> &T {
+pub(crate) fn downcast_ref<T: Debug + WasmNotSendSync + 'static>(data: &crate::Data) -> &T {
     strict_assert!(data.is::<T>());
     // Copied from std.
     unsafe { &*(data as *const dyn Any as *const T) }
 }
 
-fn downcast_mut<T: Debug + WasmNotSend + WasmNotSync + 'static>(data: &mut crate::Data) -> &mut T {
+fn downcast_mut<T: Debug + WasmNotSendSync + 'static>(data: &mut crate::Data) -> &mut T {
     strict_assert!(data.is::<T>());
     // Copied from std.
     unsafe { &mut *(data as *mut dyn Any as *mut T) }
@@ -1228,7 +1226,7 @@ pub type DeviceLostCallback = Box<dyn FnOnce(DeviceLostReason, String) + Send +
 pub type DeviceLostCallback = Box<dyn FnOnce(DeviceLostReason, String) + 'static>;
 
 /// An object safe variant of [`Context`] implemented by all types that implement [`Context`].
-pub(crate) trait DynContext: Debug + WasmNotSend + WasmNotSync {
+pub(crate) trait DynContext: Debug + WasmNotSendSync {
     fn as_any(&self) -> &dyn Any;
 
     unsafe fn instance_create_surface(
@@ -4089,7 +4087,7 @@ where
     }
 }
 
-pub trait QueueWriteBuffer: WasmNotSend + WasmNotSync {
+pub trait QueueWriteBuffer: WasmNotSendSync {
     fn slice(&self) -> &[u8];
 
     fn slice_mut(&mut self) -> &mut [u8];

wgpu/src/lib.rs

@@ -43,7 +43,7 @@ pub use wgt::{
     StencilFaceState, StencilOperation, StencilState, StorageTextureAccess, SurfaceCapabilities,
     SurfaceStatus, TextureAspect, TextureDimension, TextureFormat, TextureFormatFeatureFlags,
     TextureFormatFeatures, TextureSampleType, TextureUsages, TextureViewDimension, VertexAttribute,
-    VertexFormat, VertexStepMode, WasmNotSend, WasmNotSync, COPY_BUFFER_ALIGNMENT,
+    VertexFormat, VertexStepMode, WasmNotSend, WasmNotSendSync, WasmNotSync, COPY_BUFFER_ALIGNMENT,
     COPY_BYTES_PER_ROW_ALIGNMENT, MAP_ALIGNMENT, PUSH_CONSTANT_ALIGNMENT,
     QUERY_RESOLVE_BUFFER_ALIGNMENT, QUERY_SET_MAX_QUERIES, QUERY_SIZE, VERTEX_STRIDE_ALIGNMENT,
 };
@@ -380,10 +380,6 @@ impl Drop for Sampler {
 pub type SurfaceConfiguration = wgt::SurfaceConfiguration<Vec<TextureFormat>>;
 static_assertions::assert_impl_all!(SurfaceConfiguration: Send, Sync);
 
-trait WgpuSurfaceRequirement: WasmNotSend + WasmNotSync {}
-
-impl<T: WasmNotSend + WasmNotSync> WgpuSurfaceRequirement for T {}
-
 /// Handle to a presentable surface.
 ///
 /// A `Surface` represents a platform-specific surface (e.g. a window) onto which rendered images may
@@ -394,7 +390,7 @@ impl<T: WasmNotSend + WasmNotSync> WgpuSurfaceRequirement for T {}
 /// serves a similar role.
 pub struct Surface<'window> {
     context: Arc<C>,
-    _surface: Option<Box<dyn WgpuSurfaceRequirement + 'window>>,
+    _surface: Option<Box<dyn WasmNotSendSync + 'window>>,
     id: ObjectId,
     data: Box<Data>,
     // Stores the latest `SurfaceConfiguration` that was set using `Surface::configure`.
@@ -1966,7 +1962,7 @@ impl Instance {
         window: W,
     ) -> Result<Surface<'window>, CreateSurfaceError>
     where
-        W: HasWindowHandle + HasDisplayHandle + WasmNotSend + WasmNotSync + 'window,
+        W: HasWindowHandle + HasDisplayHandle + WasmNotSendSync + 'window,
     {
         let mut surface = unsafe { self.create_surface_from_raw(&window) }?;
         surface._surface = Some(Box::new(window));
@@ -5460,12 +5456,12 @@ mod send_sync {
     use std::any::Any;
     use std::fmt;
 
-    use wgt::{WasmNotSend, WasmNotSync};
+    use wgt::WasmNotSendSync;
 
-    pub trait AnyWasmNotSendSync: Any + WasmNotSend + WasmNotSync {
+    pub trait AnyWasmNotSendSync: Any + WasmNotSendSync {
         fn upcast_any_ref(&self) -> &dyn Any;
     }
-    impl<T: Any + WasmNotSend + WasmNotSync> AnyWasmNotSendSync for T {
+    impl<T: Any + WasmNotSendSync> AnyWasmNotSendSync for T {
         #[inline]
         fn upcast_any_ref(&self) -> &dyn Any {
             self