FIXUP: ugh yet more lint expectations

naga-cli/src/bin/naga.rs

@@ -1,6 +1,4 @@
-#![allow(clippy::manual_strip)]
 use anyhow::{anyhow, Context as _};
-#[allow(unused_imports)]
 use std::fs;
 use std::{error::Error, fmt, io::Read, path::Path, str::FromStr};
 
@@ -227,10 +225,10 @@ impl FromStr for GlslProfileArg {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         use naga::back::glsl::Version;
-        Ok(Self(if s.starts_with("core") {
-            Version::Desktop(s[4..].parse().unwrap_or(330))
-        } else if s.starts_with("es") {
-            Version::new_gles(s[2..].parse().unwrap_or(310))
+        Ok(Self(if let Some(s) = s.strip_prefix("core") {
+            Version::Desktop(s.parse().unwrap_or(330))
+        } else if let Some(s) = s.strip_prefix("es") {
+            Version::new_gles(s.parse().unwrap_or(310))
         } else {
             return Err(format!("Unknown profile: {s}"));
         }))

naga/src/arena/handlevec.rs

@@ -33,7 +33,6 @@ impl<T, U> Default for HandleVec<T, U> {
     }
 }
 
-#[allow(dead_code)]
 impl<T, U> HandleVec<T, U> {
     pub(crate) const fn new() -> Self {
         Self {
@@ -65,7 +64,10 @@ impl<T, U> HandleVec<T, U> {
         assert_eq!(handle.index(), self.inner.len());
         self.inner.push(value);
     }
+}
 
+#[cfg_attr(not(any(glsl_out, spv_out, msl_out)), expect(dead_code))]
+impl<T, U> HandleVec<T, U> {
     pub(crate) fn get(&self, handle: Handle<T>) -> Option<&U> {
         self.inner.get(handle.index())
     }

naga/src/arena/mod.rs

@@ -77,7 +77,6 @@ impl<T> Arena<T> {
     }
 
     /// Extracts the inner vector.
-    #[allow(clippy::missing_const_for_fn)] // ignore due to requirement of #![feature(const_precise_live_drops)]
     pub fn into_inner(self) -> Vec<T> {
         self.data
     }

naga/src/back/glsl/mod.rs

@@ -4200,7 +4200,7 @@ impl<'a, W: Write> Writer<'a, W> {
     }
 
     /// Helper method for writing an `ImageLoad` expression.
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     fn write_image_load(
         &mut self,
         handle: Handle<crate::Expression>,

naga/src/back/hlsl/mod.rs

@@ -153,7 +153,6 @@ pub struct OffsetsBindTarget {
 pub type BindingMap = std::collections::BTreeMap<crate::ResourceBinding, BindTarget>;
 
 /// A HLSL shader model version.
-#[allow(non_snake_case, non_camel_case_types)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, PartialOrd)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize))]
 #[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]

naga/src/back/msl/sampler.rs

@@ -156,8 +156,6 @@ pub struct InlineSampler {
 
 impl Eq for InlineSampler {}
 
-#[allow(renamed_and_removed_lints)]
-#[allow(clippy::derive_hash_xor_eq)]
 impl std::hash::Hash for InlineSampler {
     fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
         self.coord.hash(hasher);

naga/src/back/msl/writer.rs

@@ -691,7 +691,6 @@ impl<W: Write> Writer<W> {
 
     /// Finishes writing and returns the output.
     // See https://github.com/rust-lang/rust-clippy/issues/4979.
-    #[allow(clippy::missing_const_for_fn)]
     pub fn finish(self) -> W {
         self.out
     }
@@ -1404,7 +1403,7 @@ impl<W: Write> Writer<W> {
         )
     }
 
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     fn put_possibly_const_expression<C, I, E>(
         &mut self,
         expr_handle: Handle<crate::Expression>,
@@ -2505,7 +2504,6 @@ impl<W: Write> Writer<W> {
     /// [`ReadZeroSkipWrite`]: index::BoundsCheckPolicy::ReadZeroSkipWrite
     /// [`Store`]: crate::Statement::Store
     /// [`Load`]: crate::Expression::Load
-    #[allow(unused_variables)]
     fn put_bounds_checks(
         &mut self,
         mut chain: Handle<crate::Expression>,

naga/src/back/spv/block.rs

@@ -2119,7 +2119,7 @@ impl BlockContext<'_> {
     }
 
     /// Build the instructions for matrix - matrix column operations
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     fn write_matrix_matrix_column_op(
         &mut self,
         block: &mut Block,

naga/src/back/spv/helpers.rs

@@ -25,7 +25,7 @@ pub(super) fn str_bytes_to_words(bytes: &[u8]) -> Vec<Word> {
 }
 
 /// split a string into chunks and keep utf8 valid
-#[allow(unstable_name_collisions)]
+#[expect(unstable_name_collisions)]
 pub(super) fn string_to_byte_chunks(input: &str, limit: usize) -> Vec<&[u8]> {
     let mut offset: usize = 0;
     let mut start: usize = 0;

naga/src/back/spv/image.rs

@@ -727,7 +727,7 @@ impl BlockContext<'_> {
     /// Generate code for an `ImageLoad` expression.
     ///
     /// The arguments are the components of an `Expression::ImageLoad` variant.
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     pub(super) fn write_image_load(
         &mut self,
         result_type_id: Word,
@@ -807,7 +807,7 @@ impl BlockContext<'_> {
     /// Generate code for an `ImageSample` expression.
     ///
     /// The arguments are the components of an `Expression::ImageSample` variant.
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     pub(super) fn write_image_sample(
         &mut self,
         result_type_id: Word,

naga/src/back/spv/instructions.rs

@@ -282,7 +282,6 @@ impl super::Instruction {
         instruction
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub(super) fn type_image(
         id: Word,
         sampled_type_id: Word,
@@ -748,7 +747,7 @@ impl super::Instruction {
     //
     //  Ray Query Instructions
     //
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     pub(super) fn ray_query_initialize(
         query: Word,
         acceleration_structure: Word,

naga/src/back/spv/layout.rs

@@ -82,14 +82,12 @@ impl Instruction {
         }
     }
 
-    #[allow(clippy::panic)]
     pub(super) fn set_type(&mut self, id: Word) {
         assert!(self.type_id.is_none(), "Type can only be set once");
         self.type_id = Some(id);
         self.wc += 1;
     }
 
-    #[allow(clippy::panic)]
     pub(super) fn set_result(&mut self, id: Word) {
         assert!(self.result_id.is_none(), "Result can only be set once");
         self.result_id = Some(id);

naga/src/back/wgsl/writer.rs

@@ -1963,7 +1963,6 @@ impl<W: Write> Writer<W> {
     }
 
     // See https://github.com/rust-lang/rust-clippy/issues/4979.
-    #[allow(clippy::missing_const_for_fn)]
     pub fn finish(self) -> W {
         self.out
     }

naga/src/block.rs

@@ -34,7 +34,6 @@ impl Block {
         }
     }
 
-    #[allow(unused_variables)]
     pub fn push(&mut self, end: Statement, span: Span) {
         self.body.push(end);
         self.span_info.push(span);

naga/src/front/glsl/context.rs

@@ -489,7 +489,7 @@ impl<'a> Context<'a> {
                 vector = pointer;
             }
 
-            #[allow(clippy::needless_range_loop)]
+            #[expect(clippy::needless_range_loop)]
             for index in 0..size {
                 let dst = self.add_expression(
                     Expression::AccessIndex {

naga/src/front/glsl/functions.rs

@@ -200,7 +200,7 @@ impl Frontend {
         })
     }
 
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     fn matrix_one_arg(
         &mut self,
         ctx: &mut Context,
@@ -348,7 +348,6 @@ impl Frontend {
         ctx.add_expression(Expression::Compose { ty, components }, meta)
     }
 
-    #[allow(clippy::too_many_arguments)]
     fn vector_constructor(
         &mut self,
         ctx: &mut Context,
@@ -506,7 +505,6 @@ impl Frontend {
         ctx.add_expression(Expression::Compose { ty, components }, meta)
     }
 
-    #[allow(clippy::too_many_arguments)]
     fn function_call(
         &mut self,
         ctx: &mut Context,
@@ -868,7 +866,7 @@ impl Frontend {
 
     /// Processes a function call argument that appears in place of an output
     /// parameter.
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     fn process_lhs_argument(
         &mut self,
         ctx: &mut Context,

naga/src/front/spv/image.rs

@@ -482,7 +482,7 @@ impl<I: Iterator<Item = u32>> super::Frontend<I> {
         Ok(())
     }
 
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     pub(super) fn parse_image_sample(
         &mut self,
         mut words_left: u16,

naga/src/front/spv/mod.rs

@@ -1039,7 +1039,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
     /// A more complicated version of the binary op,
     /// where we force the operand to have the same type as the result.
     /// This is mostly needed for "i++" and "i--" coming from GLSL.
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     fn parse_expr_binary_op_sign_adjusted(
         &mut self,
         ctx: &mut BlockContext,
@@ -1117,7 +1117,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
     /// A version of the binary op where one or both of the arguments might need to be casted to a
     /// specific integer kind (unsigned or signed), used for operations like OpINotEqual or
     /// OpUGreaterThan.
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     fn parse_expr_int_comparison(
         &mut self,
         ctx: &mut BlockContext,
@@ -1265,7 +1265,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
         Ok(())
     }
 
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     fn insert_composite(
         &self,
         root_expr: Handle<crate::Expression>,
@@ -1389,7 +1389,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
         Ok((p_lexp_handle, p_base_ty.handle))
     }
 
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     fn parse_atomic_expr_with_value(
         &mut self,
         inst: Instruction,
@@ -4390,10 +4390,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
         overrides: &Arena<crate::Override>,
     ) -> Arena<crate::Expression> {
         let mut expressions = Arena::new();
-        #[allow(clippy::panic)]
-        {
-            assert!(self.lookup_expression.is_empty());
-        }
+        assert!(self.lookup_expression.is_empty());
         // register global variables
         for (&id, var) in self.lookup_variable.iter() {
             let span = globals.get_span(var.handle);

naga/src/front/wgsl/error.rs

@@ -1017,7 +1017,7 @@ impl<'a> Error<'a> {
                     )
                     .into(),
                 )],
-                #[allow(irrefutable_let_patterns)]
+                #[expect(irrefutable_let_patterns)]
                 notes: if let EnableExtension::Unimplemented(kind) = kind {
                     vec![format!(
                         concat!(

naga/src/front/wgsl/lower/mod.rs

@@ -372,7 +372,7 @@ pub struct ExpressionContext<'source, 'temp, 'out> {
 }
 
 impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     fn as_const(&mut self) -> ExpressionContext<'source, '_, '_> {
         ExpressionContext {
             globals: self.globals,

naga/src/front/wgsl/parse/directive/enable_extension.rs

@@ -13,14 +13,14 @@ impl EnableExtensions {
     }
 
     /// Add an enable-extension to the set requested by a module.
-    #[allow(unreachable_code)]
+    #[expect(unreachable_code)]
     pub(crate) fn add(&mut self, ext: ImplementedEnableExtension) {
         let _field: &mut bool = match ext {};
         *_field = true;
     }
 
     /// Query whether an enable-extension tracked here has been requested.
-    #[allow(unused)]
+    #[expect(unused)]
     pub(crate) const fn contains(&self, ext: ImplementedEnableExtension) -> bool {
         match ext {}
     }
@@ -37,7 +37,7 @@ impl Default for EnableExtensions {
 /// WGSL spec.: <https://www.w3.org/TR/WGSL/#enable-extensions-sec>
 #[derive(Clone, Copy, Debug, Hash, Eq, PartialEq)]
 pub enum EnableExtension {
-    #[allow(unused)]
+    #[expect(unused)]
     Implemented(ImplementedEnableExtension),
     Unimplemented(UnimplementedEnableExtension),
 }

naga/src/front/wgsl/parse/directive/language_extension.rs

@@ -9,7 +9,6 @@ use strum::VariantArray;
 /// WGSL spec.: <https://www.w3.org/TR/WGSL/#language-extensions-sec>
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum LanguageExtension {
-    #[allow(unused)]
     Implemented(ImplementedLanguageExtension),
     Unimplemented(UnimplementedLanguageExtension),
 }

naga/src/front/wgsl/parse/lexer.rs

@@ -218,7 +218,6 @@ pub(in crate::front::wgsl) struct Lexer<'a> {
     /// statements.
     last_end_offset: usize,
 
-    #[allow(dead_code)]
     pub(in crate::front::wgsl) enable_extensions: EnableExtensions,
 }
 

naga/src/lib.rs

@@ -366,7 +366,7 @@ pub enum ConservativeDepth {
 #[cfg_attr(feature = "serialize", derive(Serialize))]
 #[cfg_attr(feature = "deserialize", derive(Deserialize))]
 #[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
-#[allow(missing_docs)] // The names are self evident
+#[expect(missing_docs)] // The names are self evident
 pub enum ShaderStage {
     Vertex,
     Fragment,
@@ -1759,7 +1759,7 @@ pub enum RayQueryFunction {
         /// [`AccelerationStructure`]: TypeInner::AccelerationStructure
         acceleration_structure: Handle<Expression>,
 
-        #[allow(rustdoc::private_intra_doc_links)]
+        #[expect(rustdoc::private_intra_doc_links)]
         /// A struct of detailed parameters for the ray query.
         ///
         /// This expression should have the struct type given in

naga/src/proc/constant_evaluator.rs

@@ -164,7 +164,7 @@ macro_rules! gen_component_wise_extractor {
 
         with_dollar_sign! {
             ($d:tt) => {
-                #[allow(unused)]
+                #[allow(clippy::allow_attributes, unused)]
                 #[doc = concat!(
                     "A convenience macro for using the same RHS for each [`",
                     stringify!($target),
@@ -1259,7 +1259,7 @@ impl<'a> ConstantEvaluator<'a> {
             // bits
             crate::MathFunction::CountTrailingZeros => {
                 component_wise_concrete_int!(self, span, [arg], |e| {
-                    #[allow(clippy::useless_conversion)]
+                    #[allow(clippy::allow_attributes, clippy::useless_conversion)]
                     Ok([e
                         .trailing_zeros()
                         .try_into()
@@ -1268,7 +1268,7 @@ impl<'a> ConstantEvaluator<'a> {
             }
             crate::MathFunction::CountLeadingZeros => {
                 component_wise_concrete_int!(self, span, [arg], |e| {
-                    #[allow(clippy::useless_conversion)]
+                    #[allow(clippy::allow_attributes, clippy::useless_conversion)]
                     Ok([e
                         .leading_zeros()
                         .try_into()
@@ -1277,7 +1277,7 @@ impl<'a> ConstantEvaluator<'a> {
             }
             crate::MathFunction::CountOneBits => {
                 component_wise_concrete_int!(self, span, [arg], |e| {
-                    #[allow(clippy::useless_conversion)]
+                    #[allow(clippy::allow_attributes, clippy::useless_conversion)]
                     Ok([e
                         .count_ones()
                         .try_into()