Run rustfmt

oli-obk · oli-obk · commit b27158da1dc4 · 2020-12-27T14:23:26.000Z
diff --git a/compiler/rustc_mir/src/dataflow/framework/fmt.rs b/compiler/rustc_mir/src/dataflow/framework/fmt.rs
@@ -139,18 +139,16 @@ where
     V: DebugWithContext<C> + Eq,
 {
     fn fmt_with(&self, ctxt: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_set().entries(self.iter_enumerated().map(|this| DebugWithAdapter { this, ctxt })).finish()
+        f.debug_set()
+            .entries(self.iter_enumerated().map(|this| DebugWithAdapter { this, ctxt }))
+            .finish()
     }
 
     fn fmt_diff_with(&self, old: &Self, ctxt: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         assert_eq!(self.len(), old.len());
 
         for (new, old) in self.iter_enumerated().zip(old.iter_enumerated()) {
-            write!(f, "{:?}", DebugDiffWithAdapter {
-                new,
-                old,
-                ctxt,
-            })?;
+            write!(f, "{:?}", DebugDiffWithAdapter { new, old, ctxt })?;
         }
 
         Ok(())
@@ -201,7 +199,8 @@ impl<T, U, C> DebugWithContext<C> for (T, U)
 where
     T: DebugWithContext<C>,
     U: DebugWithContext<C>,
-{}
+{
+}
 
 impl<C> DebugWithContext<C> for rustc_middle::mir::Local {}
 impl<C> DebugWithContext<C> for crate::dataflow::move_paths::InitIndex {}
diff --git a/compiler/rustc_mir/src/dataflow/framework/lattice.rs b/compiler/rustc_mir/src/dataflow/framework/lattice.rs
@@ -107,8 +107,7 @@ impl JoinSemiLattice for () {
 impl<T: JoinSemiLattice + Clone> JoinSemiLattice for Option<T> {
     fn join(&mut self, other: &Self) -> bool {
         match (self, other) {
-            (None, None) |
-            (Some(_), None) => false,
+            (None, None) | (Some(_), None) => false,
             (this @ None, Some(val)) => {
                 *this = Some(val.clone());
                 true
diff --git a/compiler/rustc_mir/src/transform/check_consts/qualifs.rs b/compiler/rustc_mir/src/transform/check_consts/qualifs.rs
@@ -2,14 +2,14 @@
 //!
 //! See the `Qualif` trait for more info.
 
+use crate::dataflow::{fmt::DebugWithContext, JoinSemiLattice};
 use rustc_errors::ErrorReported;
+use rustc_index::bit_set::BitSet;
+use rustc_index::vec::IndexVec;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, subst::SubstsRef, AdtDef, Ty};
 use rustc_span::DUMMY_SP;
 use rustc_trait_selection::traits;
-use rustc_index::vec::IndexVec;
-use rustc_index::bit_set::BitSet;
-use crate::dataflow::{JoinSemiLattice, fmt::DebugWithContext};
 
 use super::ConstCx;
 
@@ -64,7 +64,11 @@ pub(crate) trait Qualif {
 
     /// Sometimes const fn calls cannot possibly contain the qualif, so we can treat function
     /// calls special here.
-    fn in_any_function_call(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>, _args: Option<Self::Result>) -> Option<Self::Result> {
+    fn in_any_function_call(
+        cx: &ConstCx<'_, 'tcx>,
+        ty: Ty<'tcx>,
+        _args: Option<Self::Result>,
+    ) -> Option<Self::Result> {
         Self::in_any_value_of_ty(cx, ty)
     }
 
@@ -159,7 +163,11 @@ impl Qualif for HasMutInterior {
         (!ty.is_freeze(cx.tcx.at(DUMMY_SP), cx.param_env)).then_some(())
     }
 
-    fn in_adt_inherently(cx: &ConstCx<'_, 'tcx>, adt: &'tcx AdtDef, _: SubstsRef<'tcx>) -> Option<()> {
+    fn in_adt_inherently(
+        cx: &ConstCx<'_, 'tcx>,
+        adt: &'tcx AdtDef,
+        _: SubstsRef<'tcx>,
+    ) -> Option<()> {
         // Exactly one type, `UnsafeCell`, has the `HasMutInterior` qualif inherently.
         // It arises structurally for all other types.
         (Some(adt.did) == cx.tcx.lang_items().unsafe_cell_type()).then_some(())
@@ -190,7 +198,7 @@ impl JoinSemiLattice for HasMutInteriorBehindRefState {
             (Self::OnlyHasMutInterior, Self::Yes) => {
                 *self = Self::Yes;
                 true
-            },
+            }
             (Self::OnlyHasMutInterior, Self::OnlyHasMutInterior) => false,
         }
     }
@@ -201,27 +209,47 @@ impl Qualif for HasMutInteriorBehindRef {
     type Result = HasMutInteriorBehindRefState;
 
     fn in_qualifs(qualifs: &ConstQualifs) -> Option<HasMutInteriorBehindRefState> {
-        HasMutInterior::in_qualifs(qualifs).map(|()| HasMutInteriorBehindRefState::OnlyHasMutInterior)
+        HasMutInterior::in_qualifs(qualifs)
+            .map(|()| HasMutInteriorBehindRefState::OnlyHasMutInterior)
     }
 
-    fn in_any_value_of_ty(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> Option<HasMutInteriorBehindRefState> {
+    fn in_any_value_of_ty(
+        cx: &ConstCx<'_, 'tcx>,
+        ty: Ty<'tcx>,
+    ) -> Option<HasMutInteriorBehindRefState> {
         match ty.builtin_deref(false) {
-            None => HasMutInterior::in_any_value_of_ty(cx, ty).map(|()| HasMutInteriorBehindRefState::OnlyHasMutInterior),
-            Some(tam) => HasMutInterior::in_any_value_of_ty(cx, tam.ty).map(|()| HasMutInteriorBehindRefState::Yes),
+            None => HasMutInterior::in_any_value_of_ty(cx, ty)
+                .map(|()| HasMutInteriorBehindRefState::OnlyHasMutInterior),
+            Some(tam) => HasMutInterior::in_any_value_of_ty(cx, tam.ty)
+                .map(|()| HasMutInteriorBehindRefState::Yes),
         }
     }
 
     #[instrument(skip(cx))]
-    fn in_any_function_call(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>, mut args: Option<Self::Result>) -> Option<Self::Result> {
-        args.join(&HasMutInterior::in_any_value_of_ty(cx, ty).map(|()| HasMutInteriorBehindRefState::OnlyHasMutInterior));
+    fn in_any_function_call(
+        cx: &ConstCx<'_, 'tcx>,
+        ty: Ty<'tcx>,
+        mut args: Option<Self::Result>,
+    ) -> Option<Self::Result> {
+        args.join(
+            &HasMutInterior::in_any_value_of_ty(cx, ty)
+                .map(|()| HasMutInteriorBehindRefState::OnlyHasMutInterior),
+        );
         args
     }
 
-    fn in_adt_inherently(cx: &ConstCx<'_, 'tcx>, adt: &'tcx AdtDef, substs: SubstsRef<'tcx>) -> Option<HasMutInteriorBehindRefState> {
-        HasMutInterior::in_adt_inherently(cx, adt, substs).map(|()| HasMutInteriorBehindRefState::OnlyHasMutInterior)
+    fn in_adt_inherently(
+        cx: &ConstCx<'_, 'tcx>,
+        adt: &'tcx AdtDef,
+        substs: SubstsRef<'tcx>,
+    ) -> Option<HasMutInteriorBehindRefState> {
+        HasMutInterior::in_adt_inherently(cx, adt, substs)
+            .map(|()| HasMutInteriorBehindRefState::OnlyHasMutInterior)
     }
 
-    fn in_value_behind_ref(qualif: Option<HasMutInteriorBehindRefState>) -> Option<HasMutInteriorBehindRefState> {
+    fn in_value_behind_ref(
+        qualif: Option<HasMutInteriorBehindRefState>,
+    ) -> Option<HasMutInteriorBehindRefState> {
         qualif.map(|_| HasMutInteriorBehindRefState::Yes)
     }
 }
@@ -244,7 +272,11 @@ impl Qualif for NeedsDrop {
         ty.needs_drop(cx.tcx, cx.param_env).then_some(())
     }
 
-    fn in_adt_inherently(cx: &ConstCx<'_, 'tcx>, adt: &'tcx AdtDef, _: SubstsRef<'tcx>) -> Option<()> {
+    fn in_adt_inherently(
+        cx: &ConstCx<'_, 'tcx>,
+        adt: &'tcx AdtDef,
+        _: SubstsRef<'tcx>,
+    ) -> Option<()> {
         adt.has_dtor(cx.tcx).then_some(())
     }
 }
@@ -283,7 +315,11 @@ impl Qualif for CustomEq {
 
 /// Returns `true` if this `Rvalue` contains qualif `Q`.
 #[instrument(skip(cx, in_local), fields(Q=std::any::type_name::<Q>()))]
-pub(crate) fn in_rvalue<Q, F>(cx: &ConstCx<'_, 'tcx>, in_local: &mut F, rvalue: &Rvalue<'tcx>) -> Option<Q::Result>
+pub(crate) fn in_rvalue<Q, F>(
+    cx: &ConstCx<'_, 'tcx>,
+    in_local: &mut F,
+    rvalue: &Rvalue<'tcx>,
+) -> Option<Q::Result>
 where
     Q: Qualif,
     F: FnMut(Local) -> Option<Q::Result>,
@@ -342,7 +378,11 @@ where
 
 /// Returns `true` if this `Place` contains qualif `Q`.
 #[instrument(skip(cx, in_local), fields(Q=std::any::type_name::<Q>()))]
-pub(crate) fn in_place<Q, F>(cx: &ConstCx<'_, 'tcx>, in_local: &mut F, place: PlaceRef<'tcx>) -> Option<Q::Result>
+pub(crate) fn in_place<Q, F>(
+    cx: &ConstCx<'_, 'tcx>,
+    in_local: &mut F,
+    place: PlaceRef<'tcx>,
+) -> Option<Q::Result>
 where
     Q: Qualif,
     F: FnMut(Local) -> Option<Q::Result>,
@@ -353,7 +393,7 @@ where
         match proj_elem {
             ProjectionElem::Index(index) => {
                 result.join(&in_local(index));
-            },
+            }
 
             ProjectionElem::Deref
             | ProjectionElem::Field(_, _)
@@ -378,7 +418,11 @@ where
 
 /// Returns `true` if this `Operand` contains qualif `Q`.
 #[instrument(skip(cx, in_local), fields(Q=std::any::type_name::<Q>()))]
-pub(crate) fn in_operand<Q, F>(cx: &ConstCx<'_, 'tcx>, in_local: &mut F, operand: &Operand<'tcx>) -> Option<Q::Result>
+pub(crate) fn in_operand<Q, F>(
+    cx: &ConstCx<'_, 'tcx>,
+    in_local: &mut F,
+    operand: &Operand<'tcx>,
+) -> Option<Q::Result>
 where
     Q: Qualif,
     F: FnMut(Local) -> Option<Q::Result>,
diff --git a/compiler/rustc_mir/src/transform/check_consts/resolver.rs b/compiler/rustc_mir/src/transform/check_consts/resolver.rs
@@ -7,9 +7,9 @@ use rustc_middle::mir::{self, BasicBlock, Location};
 
 use std::marker::PhantomData;
 
+use super::qualifs::QualifsPerLocal;
 use super::{qualifs, ConstCx, Qualif};
 use crate::dataflow::{self, JoinSemiLattice};
-use super::qualifs::QualifsPerLocal;
 
 /// A `Visitor` that propagates qualifs between locals. This defines the transfer function of
 /// `FlowSensitiveAnalysis`.
@@ -78,11 +78,8 @@ where
         // Though some qualifs merge the call arguments' qualifs into the result qualif.
         let mut args_qualif = None;
         for arg in args {
-            let arg = qualifs::in_operand::<Q, _>(
-                self.ccx,
-                &mut |l| self.qualifs_per_local.get(l),
-                arg,
-            );
+            let arg =
+                qualifs::in_operand::<Q, _>(self.ccx, &mut |l| self.qualifs_per_local.get(l), arg);
             args_qualif.join(&arg);
         }
 
@@ -120,11 +117,8 @@ where
         rvalue: &mir::Rvalue<'tcx>,
         location: Location,
     ) {
-        let qualif = qualifs::in_rvalue::<Q, _>(
-            self.ccx,
-            &mut |l| self.qualifs_per_local.get(l),
-            rvalue,
-        );
+        let qualif =
+            qualifs::in_rvalue::<Q, _>(self.ccx, &mut |l| self.qualifs_per_local.get(l), rvalue);
         if !place.is_indirect() {
             self.assign_qualif_direct(place, qualif);
         }
@@ -170,10 +164,7 @@ where
         FlowSensitiveAnalysis { ccx, _qualif: PhantomData }
     }
 
-    fn transfer_function(
-        &self,
-        state: &'a mut Q::Set,
-    ) -> TransferFunction<'a, 'mir, 'tcx, Q> {
+    fn transfer_function(&self, state: &'a mut Q::Set) -> TransferFunction<'a, 'mir, 'tcx, Q> {
         TransferFunction::<Q>::new(self.ccx, state)
     }
 }
diff --git a/compiler/rustc_mir/src/transform/check_consts/validation.rs b/compiler/rustc_mir/src/transform/check_consts/validation.rs
@@ -21,12 +21,15 @@ use std::mem;
 use std::ops::Deref;
 
 use super::ops::{self, NonConstOp, Status};
-use super::qualifs::{self, CustomEq, HasMutInterior, NeedsDrop, QualifsPerLocal, HasMutInteriorBehindRef, HasMutInteriorBehindRefState};
+use super::qualifs::{
+    self, CustomEq, HasMutInterior, HasMutInteriorBehindRef, HasMutInteriorBehindRefState,
+    NeedsDrop, QualifsPerLocal,
+};
 use super::resolver::FlowSensitiveAnalysis;
 use super::{is_lang_panic_fn, ConstCx, Qualif};
 use crate::const_eval::is_unstable_const_fn;
 use crate::dataflow::impls::MaybeMutBorrowedLocals;
-use crate::dataflow::{self, Analysis, lattice::JoinSemiLattice};
+use crate::dataflow::{self, lattice::JoinSemiLattice, Analysis};
 
 // We are using `MaybeMutBorrowedLocals` as a proxy for whether an item may have been mutated
 // through a pointer prior to the given point. This is okay even though `MaybeMutBorrowedLocals`
@@ -290,7 +293,9 @@ impl Validator<'mir, 'tcx> {
 
         if let hir::ConstContext::Const = self.const_kind() {
             // Ensure that we do not produce references with interior mutability behind them
-            if let Some(HasMutInteriorBehindRefState::Yes) = self.qualifs.return_place_has_mut_interior_behind_ref(self.ccx) {
+            if let Some(HasMutInteriorBehindRefState::Yes) =
+                self.qualifs.return_place_has_mut_interior_behind_ref(self.ccx)
+            {
                 // FIXME: Trace the source of the `Yes` in dataflow
                 self.span = body.local_decls[RETURN_PLACE].source_info.span;
                 self.check_op(ops::CellBorrow)
