chore: naively set warn(unsafe_ops_in_unsafe_fn) for wgpu

Do the simplest mechanical work necessary to enable and satisfy this lint; only put down `unsafe`
blocks, don't try to inspect for correctness or anything else.

Author: ErichDonGubler

wgpu/src/backend/direct.rs

@@ -40,25 +40,26 @@ impl fmt::Debug for Context {
 impl Context {
     #[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
     pub unsafe fn from_hal_instance<A: wgc::hub::HalApi>(hal_instance: A::Instance) -> Self {
-        Self(wgc::hub::Global::from_hal_instance::<A>(
-            "wgpu",
-            wgc::hub::IdentityManagerFactory,
-            hal_instance,
-        ))
+        Self(unsafe {
+            wgc::hub::Global::from_hal_instance::<A>(
+                "wgpu",
+                wgc::hub::IdentityManagerFactory,
+                hal_instance,
+            )
+        })
     }
 
     /// # Safety
     ///
     /// - The raw instance handle returned must not be manually destroyed.
     pub unsafe fn instance_as_hal<A: wgc::hub::HalApi>(&self) -> Option<&A::Instance> {
-        self.0.instance_as_hal::<A>()
+        unsafe { self.0.instance_as_hal::<A>() }
     }
 
     pub unsafe fn from_core_instance(core_instance: wgc::instance::Instance) -> Self {
-        Self(wgc::hub::Global::from_instance(
-            wgc::hub::IdentityManagerFactory,
-            core_instance,
-        ))
+        Self(unsafe {
+            wgc::hub::Global::from_instance(wgc::hub::IdentityManagerFactory, core_instance)
+        })
     }
 
     pub(crate) fn global(&self) -> &wgc::hub::Global<wgc::hub::IdentityManagerFactory> {
@@ -76,16 +77,18 @@ impl Context {
         &self,
         hal_adapter: hal::ExposedAdapter<A>,
     ) -> wgc::id::AdapterId {
-        self.0.create_adapter_from_hal(hal_adapter, ())
+        unsafe { self.0.create_adapter_from_hal(hal_adapter, ()) }
     }
 
     pub unsafe fn adapter_as_hal<A: wgc::hub::HalApi, F: FnOnce(Option<&A::Adapter>) -> R, R>(
         &self,
         adapter: wgc::id::AdapterId,
         hal_adapter_callback: F,
     ) -> R {
-        self.0
-            .adapter_as_hal::<A, F, R>(adapter, hal_adapter_callback)
+        unsafe {
+            self.0
+                .adapter_as_hal::<A, F, R>(adapter, hal_adapter_callback)
+        }
     }
 
     #[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
@@ -97,13 +100,15 @@ impl Context {
         trace_dir: Option<&std::path::Path>,
     ) -> Result<(Device, wgc::id::QueueId), crate::RequestDeviceError> {
         let global = &self.0;
-        let (device_id, error) = global.create_device_from_hal(
-            *adapter,
-            hal_device,
-            &desc.map_label(|l| l.map(Borrowed)),
-            trace_dir,
-            (),
-        );
+        let (device_id, error) = unsafe {
+            global.create_device_from_hal(
+                *adapter,
+                hal_device,
+                &desc.map_label(|l| l.map(Borrowed)),
+                trace_dir,
+                (),
+            )
+        };
         if let Some(err) = error {
             self.handle_error_fatal(err, "Adapter::create_device_from_hal");
         }
@@ -123,12 +128,14 @@ impl Context {
         desc: &TextureDescriptor,
     ) -> Texture {
         let global = &self.0;
-        let (id, error) = global.create_texture_from_hal::<A>(
-            hal_texture,
-            device.id,
-            &desc.map_label(|l| l.map(Borrowed)),
-            (),
-        );
+        let (id, error) = unsafe {
+            global.create_texture_from_hal::<A>(
+                hal_texture,
+                device.id,
+                &desc.map_label(|l| l.map(Borrowed)),
+                (),
+            )
+        };
         if let Some(cause) = error {
             self.handle_error(
                 &device.error_sink,
@@ -150,8 +157,10 @@ impl Context {
         device: &Device,
         hal_device_callback: F,
     ) -> R {
-        self.0
-            .device_as_hal::<A, F, R>(device.id, hal_device_callback)
+        unsafe {
+            self.0
+                .device_as_hal::<A, F, R>(device.id, hal_device_callback)
+        }
     }
 
     #[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
@@ -160,8 +169,10 @@ impl Context {
         texture: &Texture,
         hal_texture_callback: F,
     ) {
-        self.0
-            .texture_as_hal::<A, F>(texture.id, hal_texture_callback)
+        unsafe {
+            self.0
+                .texture_as_hal::<A, F>(texture.id, hal_texture_callback)
+        }
     }
 
     #[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
@@ -213,7 +224,7 @@ impl Context {
         self: &Arc<Self>,
         visual: *mut std::ffi::c_void,
     ) -> crate::Surface {
-        let id = self.0.instance_create_surface_from_visual(visual, ());
+        let id = unsafe { self.0.instance_create_surface_from_visual(visual, ()) };
         crate::Surface {
             context: Arc::clone(self),
             id: Surface {
@@ -1163,7 +1174,7 @@ impl crate::Context for Context {
             label: desc.label.map(Borrowed),
             // Doesn't matter the value since spirv shaders aren't mutated to include
             // runtime checks
-            shader_bound_checks: wgt::ShaderBoundChecks::unchecked(),
+            shader_bound_checks: unsafe { wgt::ShaderBoundChecks::unchecked() },
         };
         let (id, error) = wgc::gfx_select!(
             device.id => global.device_create_shader_module_spirv(device.id, &descriptor, Borrowed(&desc.source), ())

wgpu/src/lib.rs

@@ -4,7 +4,7 @@
 
 #![cfg_attr(docsrs, feature(doc_cfg))] // Allow doc(cfg(feature = "")) for showing in docs that something is feature gated.
 #![doc(html_logo_url = "https://raw.githubusercontent.com/gfx-rs/wgpu/master/logo.png")]
-#![warn(missing_docs)]
+#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
 
 mod backend;
 pub mod util;
@@ -1730,7 +1730,7 @@ impl Instance {
     #[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
     pub unsafe fn from_hal<A: wgc::hub::HalApi>(hal_instance: A::Instance) -> Self {
         Self {
-            context: Arc::new(C::from_hal_instance::<A>(hal_instance)),
+            context: Arc::new(unsafe { C::from_hal_instance::<A>(hal_instance) }),
         }
     }
 
@@ -1746,7 +1746,7 @@ impl Instance {
     /// [`Instance`]: hal::Api::Instance
     #[cfg(any(not(target_arch = "wasm32"), feature = "webgl"))]
     pub unsafe fn as_hal<A: wgc::hub::HalApi>(&self) -> Option<&A::Instance> {
-        self.context.instance_as_hal::<A>()
+        unsafe { self.context.instance_as_hal::<A>() }
     }
 
     /// Create an new instance of wgpu from a wgpu-core instance.
@@ -1761,7 +1761,7 @@ impl Instance {
     #[cfg(any(not(target_arch = "wasm32"), feature = "webgl"))]
     pub unsafe fn from_core(core_instance: wgc::instance::Instance) -> Self {
         Self {
-            context: Arc::new(C::from_core_instance(core_instance)),
+            context: Arc::new(unsafe { C::from_core_instance(core_instance) }),
         }
     }
 
@@ -1807,7 +1807,7 @@ impl Instance {
         hal_adapter: hal::ExposedAdapter<A>,
     ) -> Adapter {
         let context = Arc::clone(&self.context);
-        let id = context.create_adapter_from_hal(hal_adapter);
+        let id = unsafe { context.create_adapter_from_hal(hal_adapter) };
         Adapter { context, id }
     }
 
@@ -1854,7 +1854,7 @@ impl Instance {
     /// - visual must be a valid IDCompositionVisual to create a surface upon.
     #[cfg(target_os = "windows")]
     pub unsafe fn create_surface_from_visual(&self, visual: *mut std::ffi::c_void) -> Surface {
-        self.context.create_surface_from_visual(visual)
+        unsafe { self.context.create_surface_from_visual(visual) }
     }
 
     /// Creates a surface from a `web_sys::HtmlCanvasElement`.
@@ -1967,20 +1967,22 @@ impl Adapter {
         trace_path: Option<&std::path::Path>,
     ) -> Result<(Device, Queue), RequestDeviceError> {
         let context = Arc::clone(&self.context);
-        self.context
-            .create_device_from_hal(&self.id, hal_device, desc, trace_path)
-            .map(|(device_id, queue_id)| {
-                (
-                    Device {
-                        context: Arc::clone(&context),
-                        id: device_id,
-                    },
-                    Queue {
-                        context,
-                        id: queue_id,
-                    },
-                )
-            })
+        unsafe {
+            self.context
+                .create_device_from_hal(&self.id, hal_device, desc, trace_path)
+        }
+        .map(|(device_id, queue_id)| {
+            (
+                Device {
+                    context: Arc::clone(&context),
+                    id: device_id,
+                },
+                Queue {
+                    context,
+                    id: queue_id,
+                },
+            )
+        })
     }
 
     /// Apply a callback to this `Adapter`'s underlying backend adapter.
@@ -2007,8 +2009,10 @@ impl Adapter {
         &self,
         hal_adapter_callback: F,
     ) -> R {
-        self.context
-            .adapter_as_hal::<A, F, R>(self.id, hal_adapter_callback)
+        unsafe {
+            self.context
+                .adapter_as_hal::<A, F, R>(self.id, hal_adapter_callback)
+        }
     }
 
     /// Returns whether this adapter may present to the passed surface.
@@ -2108,12 +2112,14 @@ impl Device {
     ) -> ShaderModule {
         ShaderModule {
             context: Arc::clone(&self.context),
-            id: Context::device_create_shader_module(
-                &*self.context,
-                &self.id,
-                desc,
-                wgt::ShaderBoundChecks::unchecked(),
-            ),
+            id: unsafe {
+                Context::device_create_shader_module(
+                    &*self.context,
+                    &self.id,
+                    desc,
+                    wgt::ShaderBoundChecks::unchecked(),
+                )
+            },
         }
     }
 
@@ -2131,7 +2137,9 @@ impl Device {
     ) -> ShaderModule {
         ShaderModule {
             context: Arc::clone(&self.context),
-            id: Context::device_create_shader_module_spirv(&*self.context, &self.id, desc),
+            id: unsafe {
+                Context::device_create_shader_module_spirv(&*self.context, &self.id, desc)
+            },
         }
     }
 
@@ -2241,9 +2249,10 @@ impl Device {
     ) -> Texture {
         Texture {
             context: Arc::clone(&self.context),
-            id: self
-                .context
-                .create_texture_from_hal::<A>(hal_texture, &self.id, desc),
+            id: unsafe {
+                self.context
+                    .create_texture_from_hal::<A>(hal_texture, &self.id, desc)
+            },
             owned: true,
         }
     }
@@ -2315,8 +2324,10 @@ impl Device {
         &self,
         hal_device_callback: F,
     ) -> R {
-        self.context
-            .device_as_hal::<A, F, R>(&self.id, hal_device_callback)
+        unsafe {
+            self.context
+                .device_as_hal::<A, F, R>(&self.id, hal_device_callback)
+        }
     }
 }
 
@@ -2626,8 +2637,10 @@ impl Texture {
         &self,
         hal_texture_callback: F,
     ) {
-        self.context
-            .texture_as_hal::<A, F>(&self.id, hal_texture_callback)
+        unsafe {
+            self.context
+                .texture_as_hal::<A, F>(&self.id, hal_texture_callback)
+        }
     }
 
     /// Creates a view of this texture.