Fix clippy and formatting post-Rust 1.87. (#13)

Formatting-wise we've seen something similar in Rust-GPU, and it has to
do with the adoption of `style_edition = "2024"` in `rustfmt.toml`
before that had some "last-minute" changes.

Hopefully CI passes with the change from nightly to stable (nightly was
used due to rustfmt previously).

Author: eddyb

.github/workflows/ci.yml

@@ -18,10 +18,8 @@ jobs:
           submodules: true
       - uses: actions-rs/toolchain@v1
         with:
-          # FIXME(eddyb) `style_edition = "2024"` in `rustfmt.toml` is what keeps
-          # this on `nightly`, should switch to `stable` when that stabilizes.
-          toolchain: nightly
-          # HACK(eddyb) use `nightly` by default without breaking the ability to
+          toolchain: stable
+          # HACK(eddyb) use `stable` by default without breaking the ability to
           # temporarily bypass it through `rust-toolchain.toml`.
           default: true
           override: false
@@ -63,7 +61,7 @@ jobs:
           override: true
       # NOTE(eddyb) this is the simplest way found so far to get `glslang`.
       - name: Prepare Vulkan SDK
-        uses: humbletim/[email protected].0
+        uses: humbletim/[email protected].1
         with:
           vulkan-query-version: 1.3.250.0
           vulkan-components: Glslang SPIRV-Tools

Cargo.lock

@@ -7,7 +7,7 @@ fn main() {
         std::env::current_dir().unwrap().join("khronos-spec/SPIRV-Headers/include/spirv/unified1");
     println!("cargo:rerun-if-changed={}", khr_spv_include_dir.display());
 
-    if !std::fs::metadata(&khr_spv_include_dir).map_or(false, |m| m.is_dir()) {
+    if !std::fs::metadata(&khr_spv_include_dir).is_ok_and(|m| m.is_dir()) {
         eprintln!(" error: {} is not a directory", khr_spv_include_dir.display());
         eprintln!("  help: git submodules are required to build from a git checkout");
         eprintln!("  help: run `git submodule update --init`");

build.rs

@@ -84,17 +84,20 @@ impl ControlFlowGraph {
         func_def_body: &FuncDefBody,
     ) -> impl DoubleEndedIterator<Item = Region> {
         let mut post_order = SmallVec::<[_; 8]>::new();
-        self.traverse_whole_func(func_def_body, &mut TraversalState {
-            incoming_edge_counts: EntityOrientedDenseMap::new(),
+        self.traverse_whole_func(
+            func_def_body,
+            &mut TraversalState {
+                incoming_edge_counts: EntityOrientedDenseMap::new(),
 
-            pre_order_visit: |_| {},
-            post_order_visit: |region| post_order.push(region),
+                pre_order_visit: |_| {},
+                post_order_visit: |region| post_order.push(region),
 
-            // NOTE(eddyb) this doesn't impact semantics, but combined with
-            // the final reversal, it should keep targets in the original
-            // order in the cases when they didn't get deduplicated.
-            reverse_targets: true,
-        });
+                // NOTE(eddyb) this doesn't impact semantics, but combined with
+                // the final reversal, it should keep targets in the original
+                // order in the cases when they didn't get deduplicated.
+                reverse_targets: true,
+            },
+        );
         post_order.into_iter().rev()
     }
 }
@@ -906,10 +909,13 @@ impl DeferredEdgeBundleSet {
                     Err(new_deferred) => {
                         assert!(new_deferred.edge_bundle.target == target);
                         assert!(matches!(new_deferred.condition, LazyCond::True));
-                        (None, DeferredEdgeBundleSet::Always {
-                            target,
-                            edge_bundle: new_deferred.edge_bundle.with_target(()),
-                        })
+                        (
+                            None,
+                            DeferredEdgeBundleSet::Always {
+                                target,
+                                edge_bundle: new_deferred.edge_bundle.with_target(()),
+                            },
+                        )
                     }
                 }
             }
@@ -918,14 +924,17 @@ impl DeferredEdgeBundleSet {
                 for (i, (&target, deferred)) in target_to_deferred.iter_mut().enumerate() {
                     // HACK(eddyb) "take" `deferred` so it can be passed to
                     // `matches` (and put back if that returned `Err`).
-                    let taken_deferred = mem::replace(deferred, DeferredEdgeBundle {
-                        condition: LazyCond::False,
-                        edge_bundle: IncomingEdgeBundle {
-                            target: Default::default(),
-                            accumulated_count: Default::default(),
-                            target_inputs: Default::default(),
+                    let taken_deferred = mem::replace(
+                        deferred,
+                        DeferredEdgeBundle {
+                            condition: LazyCond::False,
+                            edge_bundle: IncomingEdgeBundle {
+                                target: Default::default(),
+                                accumulated_count: Default::default(),
+                                target_inputs: Default::default(),
+                            },
                         },
-                    });
+                    );
 
                     match matches(taken_deferred.with_target(target)) {
                         Ok(x) => {
@@ -1111,13 +1120,16 @@ impl<'a> Structurizer<'a> {
                 // in the general case (but special-cased because this is very
                 // close to being structurizable, just needs a bit of plumbing).
                 let mut control_inst_on_exit_from = EntityOrientedDenseMap::new();
-                control_inst_on_exit_from.insert(self.func_def_body.body, ControlInst {
-                    attrs: AttrSet::default(),
-                    kind: ControlInstKind::Unreachable,
-                    inputs: [].into_iter().collect(),
-                    targets: [].into_iter().collect(),
-                    target_inputs: FxIndexMap::default(),
-                });
+                control_inst_on_exit_from.insert(
+                    self.func_def_body.body,
+                    ControlInst {
+                        attrs: AttrSet::default(),
+                        kind: ControlInstKind::Unreachable,
+                        inputs: [].into_iter().collect(),
+                        targets: [].into_iter().collect(),
+                        target_inputs: FxIndexMap::default(),
+                    },
+                );
                 self.func_def_body.unstructured_cfg = Some(ControlFlowGraph {
                     control_inst_on_exit_from,
                     loop_merge_to_loop_header: Default::default(),
@@ -1133,13 +1145,15 @@ impl<'a> Structurizer<'a> {
 
             _ => {
                 // Repair all the regions that remain unclaimed, including the body.
-                let structurize_region_state = mem::take(&mut self.structurize_region_state)
-                    .into_iter()
-                    .chain([(self.func_def_body.body, StructurizeRegionState::Ready {
-                        accumulated_backedge_count: IncomingEdgeCount::default(),
+                let structurize_region_state =
+                    mem::take(&mut self.structurize_region_state).into_iter().chain([(
+                        self.func_def_body.body,
+                        StructurizeRegionState::Ready {
+                            accumulated_backedge_count: IncomingEdgeCount::default(),
 
-                        region_deferred_edges: func_body_deferred_edges,
-                    })]);
+                            region_deferred_edges: func_body_deferred_edges,
+                        },
+                    )]);
                 for (target, state) in structurize_region_state {
                     if let StructurizeRegionState::Ready { region_deferred_edges, .. } = state {
                         self.rebuild_cfg_from_unclaimed_region_deferred_edges(
@@ -1537,11 +1551,13 @@ impl<'a> Structurizer<'a> {
             .map(|backedge| backedge.accumulated_count)
             .unwrap_or_default();
 
-        let old_state =
-            self.structurize_region_state.insert(region, StructurizeRegionState::Ready {
+        let old_state = self.structurize_region_state.insert(
+            region,
+            StructurizeRegionState::Ready {
                 accumulated_backedge_count,
                 region_deferred_edges: deferred_edges,
-            });
+            },
+        );
         if !matches!(old_state, Some(StructurizeRegionState::InProgress)) {
             unreachable!(
                 "cfg::Structurizer::structurize_region: \

src/cfg.rs

@@ -228,10 +228,13 @@ impl<'a, BlockId: Copy + Eq + Hash, DefId: Copy + Eq + Hash, DefType: Copy>
             .map(|block_id| BlockIdx(self.def_map.blocks_by_id.get_index_of(&block_id).unwrap()));
 
         if self.blocks[target_block_idx].preds.insert(source_block_idx) {
-            self.add_uses_to(source_block_idx, AddUsesSource::PropagateBackwardsAcrossEdge {
-                target: target_block_idx,
-                only_dirty: false,
-            });
+            self.add_uses_to(
+                source_block_idx,
+                AddUsesSource::PropagateBackwardsAcrossEdge {
+                    target: target_block_idx,
+                    only_dirty: false,
+                },
+            );
         }
     }
 
@@ -240,10 +243,13 @@ impl<'a, BlockId: Copy + Eq + Hash, DefId: Copy + Eq + Hash, DefType: Copy>
             for i in 0..self.blocks[block_idx].preds.len() {
                 let pred_block_idx = self.blocks[block_idx].preds[i];
 
-                self.add_uses_to(pred_block_idx, AddUsesSource::PropagateBackwardsAcrossEdge {
-                    target: block_idx,
-                    only_dirty: true,
-                });
+                self.add_uses_to(
+                    pred_block_idx,
+                    AddUsesSource::PropagateBackwardsAcrossEdge {
+                        target: block_idx,
+                        only_dirty: true,
+                    },
+                );
             }
             self.blocks[block_idx].dirty_chunks.clear();
         }
@@ -452,6 +458,8 @@ mod data {
 
     // HACK(eddyb) most of the need for this arises from avoidance of
     // `unsafe` code (i.e. `MaybeUninit<V>` could suffice in most cases).
+    // FIXME(eddyb) figure out if keeping this around is useful at all.
+    #[allow(unused)]
     pub enum WrapNonDefaultValueInOption {}
     impl<V> ValueStorage<V> for WrapNonDefaultValueInOption {
         type Slot = Option<V>;

src/cfgssa.rs

@@ -51,7 +51,7 @@
 // HACK(eddyb) using `(struct.Context.html)` to link `Context`, not `context::Context`.
 //! * [`Context`](struct.Context.html): handles interning ([`Type`]s, [`Const`]s, etc.) and allocating entity handles
 //! * [`Module`]: owns [`Func`]s and [`GlobalVar`]s (rooted by [`exports`](Module::exports))
-//! * [`FuncDefBody`]: owns [`Region`]s and [DataInst]s (rooted by [`body`](FuncDefBody::body))
+//! * [`FuncDefBody`]: owns [`Region`]s and [`DataInst`]s (rooted by [`body`](FuncDefBody::body))
 //!
 //! ##### Utilities and passes
 //! * [`print`](mod@print): pretty-printer with (styled and hyperlinked) HTML output
@@ -99,7 +99,6 @@
     clippy::map_err_ignore,
     clippy::map_flatten,
     clippy::map_unwrap_or,
-    clippy::match_on_vec_items,
     clippy::match_same_arms,
     clippy::match_wild_err_arm,
     clippy::match_wildcard_for_single_variants,

src/lib.rs

@@ -1824,9 +1824,10 @@ impl Print for spv::Dialect {
                             printer.pretty_spv_print_tokens_for_operand({
                                 let mut tokens = spv::print::operand_from_imms(cap_imms(cap));
                                 tokens.tokens.drain(..tokens.tokens.len() - 1);
-                                assert!(matches!(tokens.tokens[..], [
-                                    spv::print::Token::EnumerandName(_)
-                                ]));
+                                assert!(matches!(
+                                    tokens.tokens[..],
+                                    [spv::print::Token::EnumerandName(_)]
+                                ));
                                 tokens
                             })
                         });
@@ -1955,8 +1956,12 @@ impl Print for spv::ModuleDebugInfo {
                                                             printer.pretty_string_literal(
                                                                 &printer.cx[file],
                                                             ),
-                                                            pretty::join_space(":", [printer
-                                                                .pretty_string_literal(contents)]),
+                                                            pretty::join_space(
+                                                                ":",
+                                                                [printer.pretty_string_literal(
+                                                                    contents,
+                                                                )],
+                                                            ),
                                                         ])
                                                     })
                                                     .map(|entry| {
@@ -2597,7 +2602,7 @@ impl Print for ConstDef {
                             Some(format!("{float:?}")).filter(|s| {
                                 s.parse::<FLOAT>()
                                     .map(float_to_bits)
-                                    .map_or(false, |roundtrip_bits| roundtrip_bits == bits)
+                                    .is_ok_and(|roundtrip_bits| roundtrip_bits == bits)
                             })
                         }
 
@@ -3050,10 +3055,13 @@ impl Print for FuncAt<'_, Node> {
                 let (inputs_header, body_suffix) = if !inputs.is_empty() {
                     let input_decls_and_uses =
                         inputs.iter().enumerate().map(|(input_idx, input)| {
-                            (input, Value::RegionInput {
-                                region: *body,
-                                input_idx: input_idx.try_into().unwrap(),
-                            })
+                            (
+                                input,
+                                Value::RegionInput {
+                                    region: *body,
+                                    input_idx: input_idx.try_into().unwrap(),
+                                },
+                            )
                         });
                     (
                         pretty::join_comma_sep(

src/print/mod.rs

@@ -196,7 +196,7 @@ impl Versions<pretty::FragmentPostLayout> {
                             .iter()
                             .zip(anchor_aligner.merged_columns())
                             .flat_map(|(&(_, repeat_count), column)| {
-                                iter::repeat(column).take(repeat_count)
+                                iter::repeat_n(column, repeat_count)
                             })
                             .peekable();
 
@@ -246,7 +246,7 @@ impl Versions<pretty::FragmentPostLayout> {
                                             }
                                             line
                                         }
-                                        other.map_or(false, |other| {
+                                        other.is_some_and(|other| {
                                             strip_indents(line) != strip_indents(other)
                                         })
                                     };
@@ -518,10 +518,7 @@ impl<'a> AnchorAligner<'a> {
             // Figure out which side has to wait, to align an upcoming anchor.
             let (old_at_anchor, new_at_anchor) =
                 next_anchor.map_or((false, false), |(anchor_old, anchor_new)| {
-                    (
-                        old_line_idx.map_or(false, |old| old == anchor_old),
-                        new_line_idx.map_or(false, |new| new == anchor_new),
-                    )
+                    (old_line_idx == Some(anchor_old), new_line_idx == Some(anchor_new))
                 });
             let old_line = if old_at_anchor && !new_at_anchor {
                 // Pausing "old", waiting for "new".

src/print/multiversion.rs

@@ -323,7 +323,7 @@ impl UsageMerger<'_> {
                 // complex it may be (notably, this is needed for nested arrays).
                 if b.max_size
                     .and_then(|b_max_size| b_max_size.checked_add(b_offset_in_a_element))
-                    .map_or(false, |b_in_a_max_size| b_in_a_max_size <= a_stride.get())
+                    .is_some_and(|b_in_a_max_size| b_in_a_max_size <= a_stride.get())
                 {
                     // FIXME(eddyb) this in-place merging dance only needed due to `Rc`.
                     ({
@@ -402,7 +402,7 @@ impl UsageMerger<'_> {
                     ))
                     .rev()
                     .take_while(|(a_sub_offset, a_sub_usage)| {
-                        a_sub_usage.max_size.map_or(true, |a_sub_max_size| {
+                        a_sub_usage.max_size.is_none_or(|a_sub_max_size| {
                             a_sub_offset.checked_add(a_sub_max_size).unwrap() > b_offset_in_a
                         })
                     });
@@ -585,7 +585,7 @@ impl MemTypeLayout {
                 entries.iter().all(|(&sub_offset, sub_usage)| {
                     // FIXME(eddyb) maybe this overflow should be propagated up,
                     // as a sign that `usage` is malformed?
-                    usage_offset.checked_add(sub_offset).map_or(false, |combined_offset| {
+                    usage_offset.checked_add(sub_offset).is_some_and(|combined_offset| {
                         // NOTE(eddyb) the reason this is only applicable to
                         // offset `0` is that *in all other cases*, every
                         // individual `OffsetBase` requires its own type, to
@@ -924,7 +924,7 @@ impl<'a> InferUsage<'a> {
                                 ));
                             }
                         };
-                        if data_inst_def.output_type.map_or(false, is_qptr) {
+                        if data_inst_def.output_type.is_some_and(is_qptr) {
                             if let Some(usage) = output_usage {
                                 usage_or_err_attrs_to_attach
                                     .push((Value::DataInstOutput(data_inst), usage));