New formatting

Author: willcrichton

.rustfmt.toml

@@ -1,2 +1,7 @@
 tab_spaces = 2
-imports_granularity = "Crate"
+imports_granularity = "Crate"
+overflow_delimited_expr = true
+group_imports = "StdExternalCrate"
+spaces_around_ranges = true
+use_field_init_shorthand = true
+max_width = 90

crates/flowistry/src/extensions.rs

@@ -1,6 +1,7 @@
+use std::cell::RefCell;
+
 use fluid_let::fluid_let;
 use rustc_macros::Encodable;
-use std::cell::RefCell;
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Encodable, Hash)]
 pub enum MutabilityMode {

crates/flowistry/src/indexed/impls.rs

@@ -1,8 +1,5 @@
-use super::{DefaultDomain, IndexSet, IndexedDomain, IndexedValue, ToIndex};
-use crate::{
-  mir::utils::{BodyExt, PlaceExt},
-  to_index_impl,
-};
+use std::{cell::RefCell, rc::Rc};
+
 use rustc_data_structures::fx::{FxHashMap as HashMap, FxHashSet as HashSet};
 use rustc_index::vec::IndexVec;
 use rustc_infer::infer::TyCtxtInferExt;
@@ -13,7 +10,12 @@ use rustc_middle::{
 };
 use rustc_span::def_id::DefId;
 use rustc_trait_selection::infer::InferCtxtExt;
-use std::{cell::RefCell, rc::Rc};
+
+use super::{DefaultDomain, IndexSet, IndexedDomain, IndexedValue, ToIndex};
+use crate::{
+  mir::utils::{BodyExt, PlaceExt},
+  to_index_impl,
+};
 
 rustc_index::newtype_index! {
   pub struct PlaceIndex {
@@ -52,7 +54,11 @@ impl NormalizedPlaces<'tcx> {
       let place = tcx.erase_regions(place);
       let place = tcx.infer_ctxt().enter(|infcx| {
         infcx
-          .partially_normalize_associated_types_in(ObligationCause::dummy(), param_env, place)
+          .partially_normalize_associated_types_in(
+            ObligationCause::dummy(),
+            param_env,
+            place,
+          )
           .value
       });
 
@@ -177,13 +183,10 @@ impl LocationDomain {
       .filter(|place| place.is_arg(body))
       .enumerate()
       .map(|(i, place)| {
-        (
-          *place,
-          Location {
-            block: arg_block,
-            statement_index: i,
-          },
-        )
+        (*place, Location {
+          block: arg_block,
+          statement_index: i,
+        })
       })
       .unzip();
 

crates/flowistry/src/indexed/mod.rs

@@ -1,21 +1,23 @@
-use rustc_data_structures::fx::FxHashMap as HashMap;
-use rustc_index::{
-  bit_set::BitSet,
-  vec::{Idx, IndexVec},
-};
-use rustc_mir_dataflow::{fmt::DebugWithContext, JoinSemiLattice};
 use std::{
   fmt,
   hash::Hash,
   ops::{Deref, DerefMut},
   rc::Rc,
 };
 
+use rustc_data_structures::fx::FxHashMap as HashMap;
+use rustc_index::{
+  bit_set::BitSet,
+  vec::{Idx, IndexVec},
+};
+use rustc_mir_dataflow::{fmt::DebugWithContext, JoinSemiLattice};
+
 pub mod impls;
 
 pub trait IndexedValue: Eq + Hash + Clone + Ord + fmt::Debug {
   type Index: Idx + ToIndex<Self>;
-  type Domain: IndexedDomain<Index = Self::Index, Value = Self> = DefaultDomain<Self::Index, Self>;
+  type Domain: IndexedDomain<Index = Self::Index, Value = Self> =
+    DefaultDomain<Self::Index, Self>;
 }
 
 pub trait ToIndex<T: IndexedValue> {
@@ -39,7 +41,10 @@ impl<T: IndexedValue> ToIndex<T> for &T {
 macro_rules! to_index_impl {
   ($t:ty) => {
     impl ToIndex<$t> for <$t as IndexedValue>::Index {
-      fn to_index(&self, _domain: &<$t as IndexedValue>::Domain) -> <$t as IndexedValue>::Index {
+      fn to_index(
+        &self,
+        _domain: &<$t as IndexedValue>::Domain,
+      ) -> <$t as IndexedValue>::Index {
         *self
       }
     }
@@ -281,7 +286,12 @@ where
     write!(f, "{}", Escape(elts))
   }
 
-  fn fmt_diff_with(&self, old: &Self, ctxt: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+  fn fmt_diff_with(
+    &self,
+    old: &Self,
+    ctxt: &C,
+    f: &mut fmt::Formatter<'_>,
+  ) -> fmt::Result {
     if self == old {
       return Ok(());
     }
@@ -355,14 +365,21 @@ impl<R: IndexedValue, C: IndexedValue> IndexMatrix<R, C> {
     self.ensure_row(row).insert(col)
   }
 
-  pub fn union_into_row<S2>(&mut self, into: impl ToIndex<R>, from: &IndexSet<C, S2>) -> bool
+  pub fn union_into_row<S2>(
+    &mut self,
+    into: impl ToIndex<R>,
+    from: &IndexSet<C, S2>,
+  ) -> bool
   where
     S2: ToSet<C>,
   {
     self.ensure_row(into).union(&*from.set)
   }
 
-  pub fn row<'a>(&'a self, row: impl ToIndex<R> + 'a) -> impl Iterator<Item = &'a C> + 'a {
+  pub fn row<'a>(
+    &'a self,
+    row: impl ToIndex<R> + 'a,
+  ) -> impl Iterator<Item = &'a C> + 'a {
     let row = row.to_index(&self.row_domain);
     self
       .matrix
@@ -372,23 +389,25 @@ impl<R: IndexedValue, C: IndexedValue> IndexMatrix<R, C> {
       .flatten()
   }
 
-  pub fn row_set<'a>(&'a self, row: impl ToIndex<R>) -> Option<IndexSet<C, RefSet<'a, C>>> {
+  pub fn row_set<'a>(
+    &'a self,
+    row: impl ToIndex<R>,
+  ) -> Option<IndexSet<C, RefSet<'a, C>>> {
     let row = row.to_index(&self.row_domain);
     self.matrix.get(&row).map(|set| IndexSet {
       set: RefSet(set),
       domain: self.col_domain.clone(),
     })
   }
 
-  pub fn rows<'a>(&'a self) -> impl Iterator<Item = (R::Index, IndexSet<C, RefSet<'a, C>>)> + 'a {
+  pub fn rows<'a>(
+    &'a self,
+  ) -> impl Iterator<Item = (R::Index, IndexSet<C, RefSet<'a, C>>)> + 'a {
     self.matrix.iter().map(move |(row, col)| {
-      (
-        *row,
-        IndexSet {
-          set: RefSet(col),
-          domain: self.col_domain.clone(),
-        },
-      )
+      (*row, IndexSet {
+        set: RefSet(col),
+        domain: self.col_domain.clone(),
+      })
     })
   }
 
@@ -446,7 +465,9 @@ impl<R: IndexedValue, C: IndexedValue> Clone for IndexMatrix<R, C> {
   }
 }
 
-impl<R: IndexedValue + fmt::Debug, C: IndexedValue + fmt::Debug> fmt::Debug for IndexMatrix<R, C> {
+impl<R: IndexedValue + fmt::Debug, C: IndexedValue + fmt::Debug> fmt::Debug
+  for IndexMatrix<R, C>
+{
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     write!(f, "{{")?;
 
@@ -468,8 +489,8 @@ impl<R: IndexedValue + fmt::Debug, C: IndexedValue + fmt::Debug> fmt::Debug for
   }
 }
 
-impl<R: IndexedValue + fmt::Debug, C: IndexedValue + fmt::Debug, Ctx> DebugWithContext<Ctx>
-  for IndexMatrix<R, C>
+impl<R: IndexedValue + fmt::Debug, C: IndexedValue + fmt::Debug, Ctx>
+  DebugWithContext<Ctx> for IndexMatrix<R, C>
 {
   fn fmt_with(&self, ctxt: &Ctx, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     write!(f, "{{")?;
@@ -489,7 +510,12 @@ impl<R: IndexedValue + fmt::Debug, C: IndexedValue + fmt::Debug, Ctx> DebugWithC
     write!(f, "}}<br align=\"left\" />")
   }
 
-  fn fmt_diff_with(&self, old: &Self, ctxt: &Ctx, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+  fn fmt_diff_with(
+    &self,
+    old: &Self,
+    ctxt: &Ctx,
+    f: &mut fmt::Formatter<'_>,
+  ) -> fmt::Result {
     if self == old {
       return Ok(());
     }

crates/flowistry/src/infoflow/analysis.rs

@@ -1,3 +1,14 @@
+use std::{cell::RefCell, iter, rc::Rc};
+
+use log::{debug, info};
+use rustc_data_structures::fx::FxHashMap as HashMap;
+use rustc_hir::{def_id::DefId, BodyId};
+use rustc_middle::{
+  mir::{visit::Visitor, *},
+  ty::{subst::GenericArgKind, ClosureKind, TyCtxt, TyKind},
+};
+use rustc_mir_dataflow::{Analysis, AnalysisDomain, Forward, JoinSemiLattice};
+
 use super::{FlowResults, BODY_STACK};
 use crate::{
   extensions::{is_extension_active, ContextMode, MutabilityMode, REACHED_LIBRARY},
@@ -12,15 +23,6 @@ use crate::{
     utils::{self, OperandExt, PlaceCollector, PlaceExt},
   },
 };
-use log::{debug, info};
-use rustc_data_structures::fx::FxHashMap as HashMap;
-use rustc_hir::{def_id::DefId, BodyId};
-use rustc_middle::{
-  mir::{visit::Visitor, *},
-  ty::{subst::GenericArgKind, ClosureKind, TyCtxt, TyKind},
-};
-use rustc_mir_dataflow::{Analysis, AnalysisDomain, Forward, JoinSemiLattice};
-use std::{cell::RefCell, iter, rc::Rc};
 
 pub type FlowDomain<'tcx> = IndexMatrix<Place<'tcx>, Location>;
 
@@ -103,7 +105,8 @@ impl TransferFunction<'_, '_, 'tcx> {
 
     // Remove any conflicts that aren't actually mutable, e.g. if x : &T ends up
     // as an alias of y: &mut T
-    let ignore_mut = is_extension_active(|mode| mode.mutability_mode == MutabilityMode::IgnoreMut);
+    let ignore_mut =
+      is_extension_active(|mode| mode.mutability_mode == MutabilityMode::IgnoreMut);
     if !ignore_mut {
       let body = self.analysis.body;
       let tcx = self.analysis.tcx;
@@ -126,7 +129,11 @@ impl TransferFunction<'_, '_, 'tcx> {
     }
   }
 
-  fn recurse_into_call(&mut self, call: &TerminatorKind<'tcx>, location: Location) -> bool {
+  fn recurse_into_call(
+    &mut self,
+    call: &TerminatorKind<'tcx>,
+    location: Location,
+  ) -> bool {
     let tcx = self.analysis.tcx;
     let (func, parent_args, destination) = match call {
       TerminatorKind::Call {
@@ -248,7 +255,9 @@ impl TransferFunction<'_, '_, 'tcx> {
     let parent_aliases = &self.analysis.aliases;
     let child_domain = flow.analysis.place_domain();
 
-    let translate_child_to_parent = |child: Place<'tcx>, mutated: bool| -> Option<Place<'tcx>> {
+    let translate_child_to_parent = |child: Place<'tcx>,
+                                     mutated: bool|
+     -> Option<Place<'tcx>> {
       if child.local == RETURN_PLACE && child.projection.len() == 0 {
         if child.ty(body.local_decls(), tcx).ty.is_unit() {
           return None;
@@ -279,13 +288,16 @@ impl TransferFunction<'_, '_, 'tcx> {
       let parent_arg_projected = Place::make(parent_toplevel_arg.local, &projection, tcx);
 
       let parent_arg_accessible = {
-        let mut sub_places = (0..=parent_arg_projected.projection.len()).rev().map(|i| {
-          Place::make(
-            parent_arg_projected.local,
-            &parent_arg_projected.projection[..i],
-            tcx,
-          )
-        });
+        let mut sub_places =
+          (0 ..= parent_arg_projected.projection.len())
+            .rev()
+            .map(|i| {
+              Place::make(
+                parent_arg_projected.local,
+                &parent_arg_projected.projection[.. i],
+                tcx,
+              )
+            });
 
         sub_places
           .find(|sub_place| {
@@ -314,7 +326,9 @@ impl TransferFunction<'_, '_, 'tcx> {
         let parent_deps = return_state
           .rows()
           .filter(|(_, deps)| child_deps.is_superset(deps))
-          .filter_map(|(row, _)| translate_child_to_parent(*child_domain.value(row), false))
+          .filter_map(|(row, _)| {
+            translate_child_to_parent(*child_domain.value(row), false)
+          })
           .collect::<Vec<_>>();
 
         debug!(
@@ -331,7 +345,12 @@ impl TransferFunction<'_, '_, 'tcx> {
 }
 
 impl Visitor<'tcx> for TransferFunction<'a, 'b, 'tcx> {
-  fn visit_assign(&mut self, place: &Place<'tcx>, rvalue: &Rvalue<'tcx>, location: Location) {
+  fn visit_assign(
+    &mut self,
+    place: &Place<'tcx>,
+    rvalue: &Rvalue<'tcx>,
+    location: Location,
+  ) {
     debug!("Checking {:?}: {:?} = {:?}", location, place, rvalue);
     let mut collector = PlaceCollector::default();
     collector.visit_rvalue(rvalue, location);

crates/flowistry/src/infoflow/dependencies.rs

@@ -1,3 +1,8 @@
+use log::{debug, trace};
+use rustc_middle::mir::*;
+use rustc_mir_dataflow::ResultsVisitor;
+use rustc_span::Span;
+
 use super::{
   analysis::{FlowAnalysis, FlowDomain},
   FlowResults,
@@ -11,10 +16,6 @@ use crate::{
   mir::utils::PlaceExt,
   source_map::{location_to_spans, HirSpanner},
 };
-use log::{debug, trace};
-use rustc_middle::mir::*;
-use rustc_mir_dataflow::ResultsVisitor;
-use rustc_span::Span;
 
 #[derive(Clone, Copy, Debug)]
 pub enum Direction {
@@ -187,7 +188,8 @@ pub fn compute_dependencies(
     .iter()
     .map(|_| (new_location_set(), new_place_set()))
     .collect::<Vec<_>>();
-  for ((target_places, _), (_, places)) in expanded_targets.iter().zip(outputs.iter_mut()) {
+  for ((target_places, _), (_, places)) in expanded_targets.iter().zip(outputs.iter_mut())
+  {
     places.union(target_places);
   }