Use more Rust features allowed under REPO_MSRV (#6887)

* chore: remove `std::mem::*` imports now unnecessary with `REPO_MSRV`

`std::mem::{size,align}_of{,_val}` was added to `std::prelude` in Rust
1.80; see
[`rust`#123168](rust-lang/rust#123168).

* refactor(benches): s/once_cell::Lazy/std::sync::LazyLock

Weaken our dependence on the `once_cell` crate by using functionality
from `std` instead that was upstreamed from `once_cell`, this time with
what's available in Rust 1.80+.

It's not yet possible to eliminate this dependency entirely, but do what
we can with `REPO_MSRV` for now.

* chore: remove unnecessarily `allow`'d lint rules under `REPO_MSRV`

* chore: migrate easy `allow`s to `expect` under `REPO_MSRV`

Remove or `expect` clear-cut `allow` statements that were easy for me to
figure out.

* chore: `warn` on `clippy::allow_attributes` under `REPO_MSRV`

Author: ErichDonGubler

Cargo.lock

@@ -43,7 +43,6 @@ naga = { workspace = true, features = [
     "wgsl-out",
 ] }
 nanorand.workspace = true
-once_cell.workspace = true
 pollster.workspace = true
 profiling.workspace = true
 rayon.workspace = true

benches/Cargo.toml

@@ -5,7 +5,7 @@ use std::{
 
 use criterion::{criterion_group, Criterion, Throughput};
 use nanorand::{Rng, WyRand};
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
 use crate::DeviceState;
 
@@ -60,7 +60,7 @@ impl BindGroupState {
 }
 
 fn run_bench(ctx: &mut Criterion) {
-    let state = Lazy::new(BindGroupState::new);
+    let state = LazyLock::new(BindGroupState::new);
 
     if !state
         .device_state

benches/benches/bind_groups.rs

@@ -5,8 +5,8 @@ use std::{
 
 use criterion::{criterion_group, Criterion, Throughput};
 use nanorand::{Rng, WyRand};
-use once_cell::sync::Lazy;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use std::sync::LazyLock;
 
 use crate::DeviceState;
 
@@ -424,7 +424,7 @@ impl ComputepassState {
 }
 
 fn run_bench(ctx: &mut Criterion) {
-    let state = Lazy::new(ComputepassState::new);
+    let state = LazyLock::new(ComputepassState::new);
 
     let dispatch_count = dispatch_count();
     let dispatch_count_bindless = dispatch_count_bindless();
@@ -449,7 +449,7 @@ fn run_bench(ctx: &mut Criterion) {
             group.bench_function(
                 format!("{cpasses} computepasses x {dispatch_per_pass} dispatches ({label})"),
                 |b| {
-                    Lazy::force(&state);
+                    LazyLock::force(&state);
 
                     b.iter_custom(|iters| {
                         profiling::scope!("benchmark invocation");
@@ -498,7 +498,7 @@ fn run_bench(ctx: &mut Criterion) {
         group.bench_function(
             format!("{threads} threads x {dispatch_per_pass} dispatch"),
             |b| {
-                Lazy::force(&state);
+                LazyLock::force(&state);
 
                 b.iter_custom(|iters| {
                     profiling::scope!("benchmark invocation");
@@ -538,7 +538,7 @@ fn run_bench(ctx: &mut Criterion) {
     group.throughput(Throughput::Elements(dispatch_count_bindless as _));
 
     group.bench_function(format!("{dispatch_count_bindless} dispatch"), |b| {
-        Lazy::force(&state);
+        LazyLock::force(&state);
 
         b.iter_custom(|iters| {
             profiling::scope!("benchmark invocation");
@@ -579,7 +579,7 @@ fn run_bench(ctx: &mut Criterion) {
             texture_count + storage_texture_count + storage_buffer_count
         ),
         |b| {
-            Lazy::force(&state);
+            LazyLock::force(&state);
 
             b.iter(|| state.device_state.queue.submit([]));
         },

benches/benches/computepass.rs

@@ -5,8 +5,8 @@ use std::{
 
 use criterion::{criterion_group, Criterion, Throughput};
 use nanorand::{Rng, WyRand};
-use once_cell::sync::Lazy;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use std::sync::LazyLock;
 
 use crate::DeviceState;
 
@@ -427,7 +427,7 @@ impl RenderpassState {
 }
 
 fn run_bench(ctx: &mut Criterion) {
-    let state = Lazy::new(RenderpassState::new);
+    let state = LazyLock::new(RenderpassState::new);
 
     let draw_count = draw_count();
     let vertex_buffer_count = draw_count * VERTEX_BUFFERS_PER_DRAW;
@@ -450,7 +450,7 @@ fn run_bench(ctx: &mut Criterion) {
             group.bench_function(
                 format!("{rpasses} renderpasses x {draws_per_pass} draws ({label})"),
                 |b| {
-                    Lazy::force(&state);
+                    LazyLock::force(&state);
 
                     b.iter_custom(|iters| {
                         profiling::scope!("benchmark invocation");
@@ -502,7 +502,7 @@ fn run_bench(ctx: &mut Criterion) {
     for threads in [2, 4, 8] {
         let draws_per_pass = draw_count / threads;
         group.bench_function(format!("{threads} threads x {draws_per_pass} draws"), |b| {
-            Lazy::force(&state);
+            LazyLock::force(&state);
 
             b.iter_custom(|iters| {
                 profiling::scope!("benchmark invocation");
@@ -541,7 +541,7 @@ fn run_bench(ctx: &mut Criterion) {
     group.throughput(Throughput::Elements(draw_count as _));
 
     group.bench_function(format!("{draw_count} draws"), |b| {
-        Lazy::force(&state);
+        LazyLock::force(&state);
 
         b.iter_custom(|iters| {
             profiling::scope!("benchmark invocation");
@@ -577,7 +577,7 @@ fn run_bench(ctx: &mut Criterion) {
             texture_count + vertex_buffer_count
         ),
         |b| {
-            Lazy::force(&state);
+            LazyLock::force(&state);
 
             b.iter(|| state.device_state.queue.submit([]));
         },

benches/benches/renderpass.rs

@@ -1,13 +1,13 @@
 use std::time::{Duration, Instant};
 
 use criterion::{criterion_group, Criterion, Throughput};
-use once_cell::sync::Lazy;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use std::sync::LazyLock;
 
 use crate::DeviceState;
 
 fn run_bench(ctx: &mut Criterion) {
-    let state = Lazy::new(DeviceState::new);
+    let state = LazyLock::new(DeviceState::new);
 
     const RESOURCES_TO_CREATE: usize = 8;
 
@@ -19,7 +19,7 @@ fn run_bench(ctx: &mut Criterion) {
         group.bench_function(
             format!("{threads} threads x {resources_per_thread} resource"),
             |b| {
-                Lazy::force(&state);
+                LazyLock::force(&state);
 
                 b.iter_custom(|iters| {
                     profiling::scope!("benchmark invocation");

benches/benches/resource_creation.rs

@@ -2,7 +2,6 @@
 // adapted from https://github.com/austinEng/webgpu-samples/blob/master/src/examples/computeBoids.ts
 
 use nanorand::{Rng, WyRand};
-use std::mem::size_of;
 use wgpu::util::DeviceExt;
 
 // number of boid particles to simulate

examples/src/boids/mod.rs

@@ -1,6 +1,6 @@
 use bytemuck::{Pod, Zeroable};
 use nanorand::{Rng, WyRand};
-use std::{borrow::Cow, mem::size_of};
+use std::borrow::Cow;
 use wgpu::util::DeviceExt;
 use winit::{
     event::{ElementState, KeyEvent},

examples/src/bunnymark/mod.rs

@@ -1,5 +1,5 @@
 use bytemuck::{Pod, Zeroable};
-use std::{f32::consts, mem::size_of};
+use std::f32::consts;
 use wgpu::util::DeviceExt;
 
 #[repr(C)]

examples/src/cube/mod.rs

@@ -362,8 +362,7 @@ async fn start<E: Example>(title: &str) {
     }
 
     log::info!("Entering event loop...");
-    // On native this is a result, but on wasm it's a unit type.
-    #[allow(clippy::let_unit_value)]
+    #[cfg_attr(target_arch = "wasm32", expect(clippy::let_unit_value))]
     let _ = (event_loop_function)(
         window_loop.event_loop,
         move |event: Event<()>, target: &EventLoopWindowTarget<()>| {

examples/src/framework.rs

@@ -1,6 +1,5 @@
 /// This example shows how to describe the adapter in use.
 async fn run() {
-    #[cfg_attr(target_arch = "wasm32", allow(unused_variables))]
     let adapter = {
         let instance = wgpu::Instance::default();
         #[cfg(not(target_arch = "wasm32"))]

examples/src/hello/mod.rs

@@ -1,10 +1,9 @@
-use std::{mem::size_of_val, str::FromStr};
+use std::str::FromStr;
 use wgpu::util::DeviceExt;
 
 // Indicates a u32 overflow in an intermediate Collatz value
 const OVERFLOW: u32 = 0xffffffff;
 
-#[cfg_attr(test, allow(dead_code))]
 async fn run() {
     let numbers = if std::env::args().len() <= 2 {
         let default = vec![1, 2, 3, 4];
@@ -32,7 +31,6 @@ async fn run() {
     log::info!("Steps: [{}]", disp_steps.join(", "));
 }
 
-#[cfg_attr(test, allow(dead_code))]
 async fn execute_gpu(numbers: &[u32]) -> Option<Vec<u32>> {
     // Instantiates instance of WebGPU
     let instance = wgpu::Instance::default();

examples/src/hello_compute/mod.rs

@@ -1,14 +1,10 @@
-use std::mem::size_of_val;
-
 const ARR_SIZE: usize = 128;
 
 struct ExecuteResults {
     patient_workgroup_results: Vec<u32>,
-    #[cfg_attr(test, allow(unused))]
     hasty_workgroup_results: Vec<u32>,
 }
 
-#[cfg_attr(test, allow(unused))]
 async fn run() {
     let instance = wgpu::Instance::default();
     let adapter = instance

examples/src/hello_synchronization/mod.rs

@@ -147,7 +147,10 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
 
 pub fn main() {
     let event_loop = EventLoop::new().unwrap();
-    #[allow(unused_mut)]
+    #[cfg_attr(
+        not(target_arch = "wasm32"),
+        expect(unused_mut, reason = "`wasm32` re-assigns to specify canvas")
+    )]
     let mut builder = winit::window::WindowBuilder::new();
     #[cfg(target_arch = "wasm32")]
     {

examples/src/hello_triangle/mod.rs

@@ -7,8 +7,6 @@
 //!
 //! Only parts specific to this example will be commented.
 
-use std::mem::size_of_val;
-
 use wgpu::util::DeviceExt;
 
 async fn run() {

examples/src/hello_workgroups/mod.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::arc_with_non_send_sync)] // False positive on wasm
+#![warn(clippy::allow_attributes)]
 
 pub mod framework;
 pub mod utils;

examples/src/lib.rs

@@ -1,9 +1,9 @@
 struct ExampleDesc {
     name: &'static str,
     function: fn(),
-    #[allow(dead_code)] // isn't used on native
+    #[cfg_attr(not(target_arch = "wasm32"), expect(dead_code))]
     webgl: bool,
-    #[allow(dead_code)] // isn't used on native
+    #[cfg_attr(not(target_arch = "wasm32"), expect(dead_code))]
     webgpu: bool,
 }
 

examples/src/main.rs

@@ -1,5 +1,5 @@
 use bytemuck::{Pod, Zeroable};
-use std::{f32::consts, mem::size_of};
+use std::f32::consts;
 use wgpu::util::DeviceExt;
 
 const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8UnormSrgb;

examples/src/mipmap/mod.rs

@@ -7,7 +7,7 @@
 //! *   Set the primitive_topology to PrimitiveTopology::LineList.
 //! *   Vertices and Indices describe the two points that make up a line.
 
-use std::{iter, mem::size_of};
+use std::iter;
 
 use bytemuck::{Pod, Zeroable};
 use wgpu::util::DeviceExt;
@@ -214,7 +214,7 @@ impl crate::framework::Example for Example {
         }
     }
 
-    #[allow(clippy::single_match)]
+    #[expect(clippy::single_match)]
     fn update(&mut self, event: winit::event::WindowEvent) {
         match event {
             WindowEvent::KeyboardInput {

examples/src/msaa_line/mod.rs

@@ -118,13 +118,17 @@ impl<F: Future<Output = Option<wgpu::Error>>> Future for ErrorFuture<F> {
     }
 }
 
-#[allow(dead_code)]
 struct Example {
     rt_target: wgpu::Texture,
+    #[expect(dead_code)]
     rt_view: wgpu::TextureView,
+    #[expect(dead_code)]
     sampler: wgpu::Sampler,
+    #[expect(dead_code)]
     uniform_buf: wgpu::Buffer,
+    #[expect(dead_code)]
     vertex_buf: wgpu::Buffer,
+    #[expect(dead_code)]
     index_buf: wgpu::Buffer,
     tlas_package: wgpu::TlasPackage,
     compute_pipeline: wgpu::ComputePipeline,

examples/src/ray_cube_compute/mod.rs

@@ -5,8 +5,6 @@
 //! hello-compute example does not such as mapping buffers
 //! and why use the async channels.
 
-use std::mem::size_of_val;
-
 const OVERFLOW: u32 = 0xffffffff;
 
 async fn run() {

examples/src/repeated_compute/mod.rs

@@ -1,4 +1,4 @@
-use std::{f32::consts, iter, mem::size_of, ops::Range, sync::Arc};
+use std::{f32::consts, iter, ops::Range, sync::Arc};
 
 use bytemuck::{Pod, Zeroable};
 use wgpu::util::{align_to, DeviceExt};

examples/src/shadow/mod.rs

@@ -1,5 +1,5 @@
 use bytemuck::{Pod, Zeroable};
-use std::{f32::consts, mem::size_of};
+use std::f32::consts;
 use wgpu::{util::DeviceExt, AstcBlock, AstcChannel};
 
 const IMAGE_SIZE: u32 = 256;
@@ -379,7 +379,7 @@ impl crate::framework::Example for Example {
         }
     }
 
-    #[allow(clippy::single_match)]
+    #[expect(clippy::single_match)]
     fn update(&mut self, event: winit::event::WindowEvent) {
         match event {
             winit::event::WindowEvent::CursorMoved { position, .. } => {

examples/src/skybox/mod.rs

@@ -1,5 +1,4 @@
 use bytemuck::{Pod, Zeroable};
-use std::mem::size_of;
 use wgpu::util::DeviceExt;
 
 #[repr(C)]

examples/src/srgb_blend/mod.rs

@@ -1,5 +1,4 @@
 use bytemuck::{Pod, Zeroable};
-use std::mem::size_of;
 use wgpu::util::DeviceExt;
 
 #[repr(C)]

examples/src/stencil_triangles/mod.rs

@@ -14,8 +14,6 @@
 //! A lot of things aren't explained here via comments. See hello-compute and
 //! repeated-compute for code that is more thoroughly commented.
 
-use std::mem::size_of_val;
-
 #[cfg(not(target_arch = "wasm32"))]
 use crate::utils::output_image_native;
 #[cfg(target_arch = "wasm32")]

examples/src/storage_texture/mod.rs

@@ -1,8 +1,5 @@
 use bytemuck::{Pod, Zeroable};
-use std::{
-    mem::size_of,
-    num::{NonZeroU32, NonZeroU64},
-};
+use std::num::{NonZeroU32, NonZeroU64};
 use wgpu::util::DeviceExt;
 
 #[repr(C)]