Update Repo MSRV to 1.91

Author: cwfitzgerald

examples/features/src/ray_cube_compute/mod.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, future::Future, iter, mem, pin::Pin, task};
+use std::{borrow::Cow, iter, mem};
 
 use bytemuck::{Pod, Zeroable};
 use glam::{Affine3A, Mat4, Quat, Vec3};
@@ -98,28 +98,6 @@ fn affine_to_rows(mat: &Affine3A) -> [f32; 12] {
     ]
 }
 
-/// A wrapper for `pop_error_scope` futures that panics if an error occurs.
-///
-/// Given a future `inner` of an `Option<E>` for some error type `E`,
-/// wait for the future to be ready, and panic if its value is `Some`.
-///
-/// This can be done simpler with `FutureExt`, but we don't want to add
-/// a dependency just for this small case.
-struct ErrorFuture<F> {
-    inner: F,
-}
-impl<F: Future<Output = Option<wgpu::Error>>> Future for ErrorFuture<F> {
-    type Output = ();
-    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<()> {
-        let inner = unsafe { self.map_unchecked_mut(|me| &mut me.inner) };
-        inner.poll(cx).map(|error| {
-            if let Some(e) = error {
-                panic!("Rendering {e}");
-            }
-        })
-    }
-}
-
 struct Example {
     rt_target: wgpu::Texture,
     #[expect(dead_code)]

examples/features/src/ray_cube_fragment/mod.rs

@@ -2,7 +2,7 @@ use crate::utils;
 use bytemuck::{Pod, Zeroable};
 use glam::{Mat4, Quat, Vec3};
 use std::ops::IndexMut;
-use std::{borrow::Cow, future::Future, iter, mem, pin::Pin, task};
+use std::{borrow::Cow, iter, mem};
 use wgpu::util::DeviceExt;
 
 // from cube
@@ -73,28 +73,6 @@ struct Uniforms {
     proj_inverse: Mat4,
 }
 
-/// A wrapper for `pop_error_scope` futures that panics if an error occurs.
-///
-/// Given a future `inner` of an `Option<E>` for some error type `E`,
-/// wait for the future to be ready, and panic if its value is `Some`.
-///
-/// This can be done simpler with `FutureExt`, but we don't want to add
-/// a dependency just for this small case.
-struct ErrorFuture<F> {
-    inner: F,
-}
-impl<F: Future<Output = Option<wgpu::Error>>> Future for ErrorFuture<F> {
-    type Output = ();
-    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<()> {
-        let inner = unsafe { self.map_unchecked_mut(|me| &mut me.inner) };
-        inner.poll(cx).map(|error| {
-            if let Some(e) = error {
-                panic!("Rendering {e}");
-            }
-        })
-    }
-}
-
 struct Example {
     uniforms: Uniforms,
     uniform_buf: wgpu::Buffer,

examples/features/src/ray_cube_normals/mod.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, future::Future, iter, mem, pin::Pin, task};
+use std::{borrow::Cow, iter, mem};
 
 use bytemuck::{Pod, Zeroable};
 use glam::{Affine3A, Mat4, Quat, Vec3};
@@ -97,28 +97,6 @@ fn affine_to_rows(mat: &Affine3A) -> [f32; 12] {
     ]
 }
 
-/// A wrapper for `pop_error_scope` futures that panics if an error occurs.
-///
-/// Given a future `inner` of an `Option<E>` for some error type `E`,
-/// wait for the future to be ready, and panic if its value is `Some`.
-///
-/// This can be done simpler with `FutureExt`, but we don't want to add
-/// a dependency just for this small case.
-struct ErrorFuture<F> {
-    inner: F,
-}
-impl<F: Future<Output = Option<wgpu::Error>>> Future for ErrorFuture<F> {
-    type Output = ();
-    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<()> {
-        let inner = unsafe { self.map_unchecked_mut(|me| &mut me.inner) };
-        inner.poll(cx).map(|error| {
-            if let Some(e) = error {
-                panic!("Rendering {e}");
-            }
-        })
-    }
-}
-
 struct Example {
     rt_target: wgpu::Texture,
     tlas: wgpu::Tlas,

examples/features/src/ray_scene/mod.rs

@@ -3,7 +3,7 @@ use bytemuck::{Pod, Zeroable};
 use glam::{Mat4, Quat, Vec3};
 use std::f32::consts::PI;
 use std::ops::IndexMut;
-use std::{borrow::Cow, future::Future, iter, mem, ops::Range, pin::Pin, task};
+use std::{borrow::Cow, iter, mem, ops::Range};
 use wgpu::util::DeviceExt;
 
 // from cube
@@ -25,28 +25,6 @@ struct Uniforms {
     proj_inverse: Mat4,
 }
 
-/// A wrapper for `pop_error_scope` futures that panics if an error occurs.
-///
-/// Given a future `inner` of an `Option<E>` for some error type `E`,
-/// wait for the future to be ready, and panic if its value is `Some`.
-///
-/// This can be done simpler with `FutureExt`, but we don't want to add
-/// a dependency just for this small case.
-struct ErrorFuture<F> {
-    inner: F,
-}
-impl<F: Future<Output = Option<wgpu::Error>>> Future for ErrorFuture<F> {
-    type Output = ();
-    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<()> {
-        let inner = unsafe { self.map_unchecked_mut(|me| &mut me.inner) };
-        inner.poll(cx).map(|error| {
-            if let Some(e) = error {
-                panic!("Rendering {e}");
-            }
-        })
-    }
-}
-
 #[derive(Debug, Clone, Default)]
 struct RawSceneComponents {
     vertices: Vec<Vertex>,

examples/features/src/ray_shadows/mod.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, future::Future, iter, mem, pin::Pin, task};
+use std::{borrow::Cow, iter, mem};
 
 use bytemuck::{Pod, Zeroable};
 use glam::{Mat4, Vec3};
@@ -52,28 +52,6 @@ struct Uniforms {
     vertex: Mat4,
 }
 
-/// A wrapper for `pop_error_scope` futures that panics if an error occurs.
-///
-/// Given a future `inner` of an `Option<E>` for some error type `E`,
-/// wait for the future to be ready, and panic if its value is `Some`.
-///
-/// This can be done simpler with `FutureExt`, but we don't want to add
-/// a dependency just for this small case.
-struct ErrorFuture<F> {
-    inner: F,
-}
-impl<F: Future<Output = Option<wgpu::Error>>> Future for ErrorFuture<F> {
-    type Output = ();
-    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<()> {
-        let inner = unsafe { self.map_unchecked_mut(|me| &mut me.inner) };
-        inner.poll(cx).map(|error| {
-            if let Some(e) = error {
-                panic!("Rendering {e}");
-            }
-        })
-    }
-}
-
 struct Example {
     uniforms: Uniforms,
     uniform_buf: wgpu::Buffer,

examples/features/src/shadow/mod.rs

@@ -494,7 +494,7 @@ impl crate::framework::Example for Example {
                     module: &shader,
                     entry_point: Some("vs_bake"),
                     compilation_options: Default::default(),
-                    buffers: &[vb_desc.clone()],
+                    buffers: std::slice::from_ref(&vb_desc),
                 },
                 fragment: None,
                 primitive: wgpu::PrimitiveState {

naga/src/back/mod.rs

@@ -215,6 +215,10 @@ impl FunctionCtx<'_> {
                     external_texture_key,
                 )
             }
+            // This is a const function, which _sometimes_ gets called,
+            // so this lint is _sometimes_ triggered, depending on feature set.
+            #[expect(clippy::allow_attributes)]
+            #[allow(clippy::panic)]
             FunctionType::EntryPoint(_) => {
                 panic!("External textures cannot be used as arguments to entry points")
             }

naga/src/back/msl/sampler.rs

@@ -5,20 +5,15 @@ use serde::Deserialize;
 #[cfg(feature = "serialize")]
 use serde::Serialize;
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
 pub enum Coord {
+    #[default]
     Normalized,
     Pixel,
 }
 
-impl Default for Coord {
-    fn default() -> Self {
-        Self::Normalized
-    }
-}
-
 impl Coord {
     pub const fn as_str(&self) -> &'static str {
         match *self {
@@ -28,23 +23,18 @@ impl Coord {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
 pub enum Address {
     Repeat,
     MirroredRepeat,
+    #[default]
     ClampToEdge,
     ClampToZero,
     ClampToBorder,
 }
 
-impl Default for Address {
-    fn default() -> Self {
-        Self::ClampToEdge
-    }
-}
-
 impl Address {
     pub const fn as_str(&self) -> &'static str {
         match *self {
@@ -57,21 +47,16 @@ impl Address {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
 pub enum BorderColor {
+    #[default]
     TransparentBlack,
     OpaqueBlack,
     OpaqueWhite,
 }
 
-impl Default for BorderColor {
-    fn default() -> Self {
-        Self::TransparentBlack
-    }
-}
-
 impl BorderColor {
     pub const fn as_str(&self) -> &'static str {
         match *self {
@@ -82,10 +67,11 @@ impl BorderColor {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
 pub enum Filter {
+    #[default]
     Nearest,
     Linear,
 }
@@ -99,16 +85,11 @@ impl Filter {
     }
 }
 
-impl Default for Filter {
-    fn default() -> Self {
-        Self::Nearest
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
 pub enum CompareFunc {
+    #[default]
     Never,
     Less,
     LessEqual,
@@ -119,12 +100,6 @@ pub enum CompareFunc {
     Always,
 }
 
-impl Default for CompareFunc {
-    fn default() -> Self {
-        Self::Never
-    }
-}
-
 impl CompareFunc {
     pub const fn as_str(&self) -> &'static str {
         match *self {

naga/src/back/spv/helpers.rs

@@ -34,7 +34,7 @@ pub(super) fn string_to_byte_chunks(input: &str, limit: usize) -> Vec<&[u8]> {
     let mut start: usize = 0;
     let mut words = vec![];
     while offset < input.len() {
-        offset = input.floor_char_boundary(offset + limit);
+        offset = input.floor_char_boundary_polyfill(offset + limit);
         // Clippy wants us to call as_bytes() first to avoid the UTF-8 check,
         // but we want to assert the output is valid UTF-8.
         #[allow(clippy::sliced_string_as_bytes)]
@@ -123,30 +123,31 @@ pub fn global_needs_wrapper(ir_module: &crate::Module, var: &crate::GlobalVariab
 }
 
 ///HACK: this is taken from std unstable, remove it when std's floor_char_boundary is stable
+/// and available in our msrv.
 trait U8Internal {
-    fn is_utf8_char_boundary(&self) -> bool;
+    fn is_utf8_char_boundary_polyfill(&self) -> bool;
 }
 
 impl U8Internal for u8 {
-    fn is_utf8_char_boundary(&self) -> bool {
+    fn is_utf8_char_boundary_polyfill(&self) -> bool {
         // This is bit magic equivalent to: b < 128 || b >= 192
         (*self as i8) >= -0x40
     }
 }
 
 trait StrUnstable {
-    fn floor_char_boundary(&self, index: usize) -> usize;
+    fn floor_char_boundary_polyfill(&self, index: usize) -> usize;
 }
 
 impl StrUnstable for str {
-    fn floor_char_boundary(&self, index: usize) -> usize {
+    fn floor_char_boundary_polyfill(&self, index: usize) -> usize {
         if index >= self.len() {
             self.len()
         } else {
             let lower_bound = index.saturating_sub(3);
             let new_index = self.as_bytes()[lower_bound..=index]
                 .iter()
-                .rposition(|b| b.is_utf8_char_boundary());
+                .rposition(|b| b.is_utf8_char_boundary_polyfill());
 
             // SAFETY: we know that the character boundary will be within four bytes
             unsafe { lower_bound + new_index.unwrap_unchecked() }

naga/src/proc/overloads/list.rs

@@ -162,6 +162,10 @@ impl crate::proc::overloads::OverloadSet for List {
 }
 
 const fn len_to_full_mask(n: usize) -> u64 {
+    // This is a const function, which _sometimes_ gets called,
+    // so this lint is _sometimes_ triggered, depending on feature set.
+    #[expect(clippy::allow_attributes)]
+    #[allow(clippy::panic)]
     if n >= 64 {
         panic!("List::rules can only hold up to 63 rules");
     }