cargo fmt, newer stable added more reformatting

Author: Firestar99

src/cfg.rs

@@ -2,10 +2,9 @@
 
 use crate::transform::{InnerInPlaceTransform as _, Transformer};
 use crate::{
-    spv, AttrSet, Const, ConstDef, ConstKind, Context, ControlNode, ControlNodeDef,
-    ControlNodeKind, ControlNodeOutputDecl, ControlRegion, ControlRegionDef,
-    EntityOrientedDenseMap, FuncDefBody, FxIndexMap, FxIndexSet, SelectionKind, Type, TypeKind,
-    Value,
+    AttrSet, Const, ConstDef, ConstKind, Context, ControlNode, ControlNodeDef, ControlNodeKind,
+    ControlNodeOutputDecl, ControlRegion, ControlRegionDef, EntityOrientedDenseMap, FuncDefBody,
+    FxIndexMap, FxIndexSet, SelectionKind, Type, TypeKind, Value, spv,
 };
 use itertools::{Either, Itertools};
 use smallvec::SmallVec;
@@ -85,20 +84,17 @@ impl ControlFlowGraph {
         func_def_body: &FuncDefBody,
     ) -> impl DoubleEndedIterator<Item = ControlRegion> {
         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()
     }
 }
@@ -912,13 +908,10 @@ 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(()),
+                        })
                     }
                 }
             }
@@ -927,17 +920,14 @@ 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) => {
@@ -1123,16 +1113,13 @@ 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(),
@@ -1148,15 +1135,13 @@ 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(
@@ -1559,13 +1544,11 @@ 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/cfgssa.rs

@@ -228,13 +228,10 @@ 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,
+            });
         }
     }
 
@@ -243,13 +240,10 @@ 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();
         }

src/passes/legalize.rs

@@ -1,6 +1,6 @@
 use crate::visit::{InnerVisit, Visitor};
 use crate::{
-    cfg, AttrSet, Const, Context, DataInstForm, DeclDef, Func, FxIndexSet, GlobalVar, Module, Type,
+    AttrSet, Const, Context, DataInstForm, DeclDef, Func, FxIndexSet, GlobalVar, Module, Type, cfg,
 };
 
 /// Apply the [`cfg::Structurizer`] algorithm to all function definitions in `module`.

src/passes/qptr.rs

@@ -1,8 +1,8 @@
 //! [`QPtr`](crate::TypeKind::QPtr) transforms.
 
 use crate::visit::{InnerVisit, Visitor};
-use crate::{qptr, DataInstForm};
 use crate::{AttrSet, Const, Context, Func, FxIndexSet, GlobalVar, Module, Type};
+use crate::{DataInstForm, qptr};
 
 pub fn lower_from_spv_ptrs(module: &mut Module, layout_config: &qptr::LayoutConfig) {
     let cx = &module.cx();

src/print/mod.rs

@@ -24,13 +24,13 @@ use crate::print::multiversion::Versions;
 use crate::qptr::{self, QPtrAttr, QPtrMemUsage, QPtrMemUsageKind, QPtrOp, QPtrUsage};
 use crate::visit::{InnerVisit, Visit, Visitor};
 use crate::{
-    cfg, spv, AddrSpace, Attr, AttrSet, AttrSetDef, Const, ConstDef, ConstKind, Context,
-    ControlNode, ControlNodeDef, ControlNodeKind, ControlNodeOutputDecl, ControlRegion,
-    ControlRegionDef, ControlRegionInputDecl, DataInst, DataInstDef, DataInstForm, DataInstFormDef,
-    DataInstKind, DeclDef, Diag, DiagLevel, DiagMsgPart, EntityListIter, ExportKey, Exportee, Func,
-    FuncDecl, FuncParam, FxIndexMap, FxIndexSet, GlobalVar, GlobalVarDecl, GlobalVarDefBody,
-    Import, Module, ModuleDebugInfo, ModuleDialect, OrdAssertEq, SelectionKind, Type, TypeDef,
-    TypeKind, TypeOrConst, Value,
+    AddrSpace, Attr, AttrSet, AttrSetDef, Const, ConstDef, ConstKind, Context, ControlNode,
+    ControlNodeDef, ControlNodeKind, ControlNodeOutputDecl, ControlRegion, ControlRegionDef,
+    ControlRegionInputDecl, DataInst, DataInstDef, DataInstForm, DataInstFormDef, DataInstKind,
+    DeclDef, Diag, DiagLevel, DiagMsgPart, EntityListIter, ExportKey, Exportee, Func, FuncDecl,
+    FuncParam, FxIndexMap, FxIndexSet, GlobalVar, GlobalVarDecl, GlobalVarDefBody, Import, Module,
+    ModuleDebugInfo, ModuleDialect, OrdAssertEq, SelectionKind, Type, TypeDef, TypeKind,
+    TypeOrConst, Value, cfg, spv,
 };
 use arrayvec::ArrayVec;
 use itertools::Either;
@@ -1839,10 +1839,9 @@ 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
                             })
                         });
@@ -1971,12 +1970,8 @@ 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| {
@@ -2999,13 +2994,10 @@ impl Print for FuncAt<'_, ControlNode> {
                 let (inputs_header, body_suffix) = if !inputs.is_empty() {
                     let input_decls_and_uses =
                         inputs.iter().enumerate().map(|(input_idx, input)| {
-                            (
-                                input,
-                                Value::ControlRegionInput {
-                                    region: *body,
-                                    input_idx: input_idx.try_into().unwrap(),
-                                },
-                            )
+                            (input, Value::ControlRegionInput {
+                                region: *body,
+                                input_idx: input_idx.try_into().unwrap(),
+                            })
                         });
                     (
                         pretty::join_comma_sep(

src/print/multiversion.rs

@@ -1,7 +1,7 @@
 //! Multi-version pretty-printing support (e.g. for comparing the IR between passes).
 
-use crate::print::pretty::{self, TextOp};
 use crate::FxIndexMap;
+use crate::print::pretty::{self, TextOp};
 use internal_iterator::{
     FromInternalIterator, InternalIterator, IntoInternalIterator, IteratorExt,
 };

src/qptr/analyze.rs

@@ -1,9 +1,9 @@
 //! [`QPtr`](crate::TypeKind::QPtr) usage analysis (for legalizing/lifting).
 
 // HACK(eddyb) sharing layout code with other modules.
-use super::{layout::*, QPtrMemUsageKind};
+use super::{QPtrMemUsageKind, layout::*};
 
-use super::{shapes, QPtrAttr, QPtrMemUsage, QPtrOp, QPtrUsage};
+use super::{QPtrAttr, QPtrMemUsage, QPtrOp, QPtrUsage, shapes};
 use crate::func_at::FuncAt;
 use crate::visit::{InnerVisit, Visitor};
 use crate::{

src/qptr/layout.rs

@@ -2,7 +2,7 @@
 
 use crate::qptr::shapes;
 use crate::{
-    spv, AddrSpace, Attr, Const, ConstKind, Context, Diag, FxIndexMap, Type, TypeKind, TypeOrConst,
+    AddrSpace, Attr, Const, ConstKind, Context, Diag, FxIndexMap, Type, TypeKind, TypeOrConst, spv,
 };
 use itertools::Either;
 use smallvec::SmallVec;

src/qptr/lift.rs

@@ -4,13 +4,13 @@
 use super::layout::*;
 
 use crate::func_at::FuncAtMut;
-use crate::qptr::{shapes, QPtrAttr, QPtrMemUsage, QPtrMemUsageKind, QPtrOp, QPtrUsage};
+use crate::qptr::{QPtrAttr, QPtrMemUsage, QPtrMemUsageKind, QPtrOp, QPtrUsage, shapes};
 use crate::transform::{InnerInPlaceTransform, InnerTransform, Transformed, Transformer};
 use crate::{
-    spv, AddrSpace, Attr, AttrSet, AttrSetDef, Const, ConstDef, ConstKind, Context, ControlNode,
+    AddrSpace, Attr, AttrSet, AttrSetDef, Const, ConstDef, ConstKind, Context, ControlNode,
     ControlNodeKind, DataInst, DataInstDef, DataInstFormDef, DataInstKind, DeclDef, Diag,
     DiagLevel, EntityDefs, EntityOrientedDenseMap, Func, FuncDecl, FxIndexMap, GlobalVar,
-    GlobalVarDecl, Module, Type, TypeDef, TypeKind, TypeOrConst, Value,
+    GlobalVarDecl, Module, Type, TypeDef, TypeKind, TypeOrConst, Value, spv,
 };
 use smallvec::SmallVec;
 use std::cell::Cell;
@@ -520,15 +520,12 @@ impl LiftToSpvPtrInstsInFunc<'_> {
                     _ => return Err(LiftError(Diag::bug(["non-Buffer pointee".into()]))),
                 };
 
-                self.deferred_ptr_noops.insert(
-                    data_inst,
-                    DeferredPtrNoop {
-                        output_pointer: buf_ptr,
-                        output_pointer_addr_space: addr_space,
-                        output_pointee_layout: buf_data_layout,
-                        parent_block,
-                    },
-                );
+                self.deferred_ptr_noops.insert(data_inst, DeferredPtrNoop {
+                    output_pointer: buf_ptr,
+                    output_pointer_addr_space: addr_space,
+                    output_pointee_layout: buf_data_layout,
+                    parent_block,
+                });
 
                 DataInstDef {
                     // FIXME(eddyb) avoid the repeated call to `type_of_val`
@@ -557,10 +554,10 @@ impl LiftToSpvPtrInstsInFunc<'_> {
                                 last_field.mem_layout.fixed_base.size == 0
                                     && last_field.mem_layout.dyn_unit_stride
                                         == Some(dyn_unit_stride)
-                                    && matches!(
-                                        last_field.components,
-                                        Components::Elements { fixed_len: None, .. }
-                                    )
+                                    && matches!(last_field.components, Components::Elements {
+                                        fixed_len: None,
+                                        ..
+                                    })
                             }) =>
                     {
                         u32::try_from(offsets.len() - 1).unwrap()
@@ -660,15 +657,12 @@ impl LiftToSpvPtrInstsInFunc<'_> {
                 }
 
                 if access_chain_inputs.len() == 1 {
-                    self.deferred_ptr_noops.insert(
-                        data_inst,
-                        DeferredPtrNoop {
-                            output_pointer: base_ptr,
-                            output_pointer_addr_space: addr_space,
-                            output_pointee_layout: TypeLayout::Concrete(layout),
-                            parent_block,
-                        },
-                    );
+                    self.deferred_ptr_noops.insert(data_inst, DeferredPtrNoop {
+                        output_pointer: base_ptr,
+                        output_pointer_addr_space: addr_space,
+                        output_pointee_layout: TypeLayout::Concrete(layout),
+                        parent_block,
+                    });
                     DataInstDef {
                         // FIXME(eddyb) avoid the repeated call to `type_of_val`
                         // (and the interning of a temporary `DataInstFormDef`),

src/qptr/lower.rs

@@ -4,12 +4,12 @@
 use super::layout::*;
 
 use crate::func_at::FuncAtMut;
-use crate::qptr::{shapes, QPtrAttr, QPtrOp};
+use crate::qptr::{QPtrAttr, QPtrOp, shapes};
 use crate::transform::{InnerInPlaceTransform, Transformed, Transformer};
 use crate::{
-    spv, AddrSpace, AttrSet, AttrSetDef, Const, ConstDef, ConstKind, Context, ControlNode,
+    AddrSpace, AttrSet, AttrSetDef, Const, ConstDef, ConstKind, Context, ControlNode,
     ControlNodeKind, DataInst, DataInstDef, DataInstForm, DataInstFormDef, DataInstKind, Diag,
-    FuncDecl, GlobalVarDecl, OrdAssertEq, Type, TypeKind, TypeOrConst, Value,
+    FuncDecl, GlobalVarDecl, OrdAssertEq, Type, TypeKind, TypeOrConst, Value, spv,
 };
 use smallvec::SmallVec;
 use std::cell::Cell;