cargo fmt as always

Author: yaahc

chalk-engine/src/context.rs

@@ -266,7 +266,6 @@ pub trait ContextOps<C: Context>: Sized + Clone + Debug + AggregateOps<C> {
         u_canon: &C::UCanonicalGoalInEnvironment,
         canonical_subst: &C::CanonicalAnswerSubst,
     ) -> bool;
-
 }
 
 /// Methods for combining solutions to yield an aggregate solution.

chalk-engine/src/logic.rs

@@ -1409,7 +1409,9 @@ impl<'forest, C: Context + 'forest, CO: ContextOps<C> + 'forest> SolveState<'for
         // must be backed by an impl *eventually*).
         let is_trivial_answer = {
             !answer.ambiguous
-                && self.context.is_trivial_substitution(&self.forest.tables[table].table_goal, &answer.subst)
+                && self
+                    .context
+                    .is_trivial_substitution(&self.forest.tables[table].table_goal, &answer.subst)
                 && C::empty_constraints(&answer.subst)
         };
 

chalk-integration/src/program.rs

@@ -4,7 +4,7 @@ use chalk_ir::debug::Angle;
 use chalk_ir::interner::ChalkIr;
 use chalk_ir::tls;
 use chalk_ir::{
-    Ty, AliasTy, AssocTypeId, ImplId, Parameter, ProgramClause, StructId, TraitId, TyData, TypeName,
+    AliasTy, AssocTypeId, ImplId, Parameter, ProgramClause, StructId, TraitId, Ty, TyData, TypeName,
 };
 use chalk_rust_ir::{
     AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ImplDatum, ImplType, StructDatum,
@@ -121,11 +121,7 @@ impl tls::DebugContext for Program {
         )
     }
 
-    fn debug_ty(
-        &self,
-        ty: &Ty<ChalkIr>,
-        fmt: &mut fmt::Formatter<'_>,
-    ) -> Result<(), fmt::Error> {
+    fn debug_ty(&self, ty: &Ty<ChalkIr>, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         let interner = self.interner();
         write!(fmt, "{:?}", ty.data(interner))
     }

chalk-ir/src/could_match.rs

@@ -14,7 +14,7 @@ where
     I: Interner,
 {
     fn could_match(&self, interner: &I, other: &T) -> bool {
-        return Zip::zip_with(&mut MatchZipper{ interner }, self, other).is_ok();
+        return Zip::zip_with(&mut MatchZipper { interner }, self, other).is_ok();
 
         struct MatchZipper<'i, I> {
             interner: &'i I,
@@ -60,7 +60,9 @@ where
 impl<I: Interner> CouldMatch<DomainGoal<I>> for ProgramClause<I> {
     fn could_match(&self, interner: &I, other: &DomainGoal<I>) -> bool {
         match self {
-            ProgramClause::Implies(implication) => implication.consequence.could_match(interner, other),
+            ProgramClause::Implies(implication) => {
+                implication.consequence.could_match(interner, other)
+            }
 
             ProgramClause::ForAll(clause) => clause.value.consequence.could_match(interner, other),
         }

chalk-ir/src/debug.rs

@@ -27,7 +27,6 @@ impl<I: Interner> Debug for Ty<I> {
     }
 }
 
-
 impl Display for UniverseIndex {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         write!(fmt, "U{}", self.counter)

chalk-ir/src/interner.rs

@@ -7,8 +7,8 @@ use crate::Parameter;
 use crate::ParameterData;
 use crate::StructId;
 use crate::TraitId;
-use crate::TyData;
 use crate::Ty;
+use crate::TyData;
 use chalk_engine::context::Context;
 use chalk_engine::ExClause;
 use std::fmt::{self, Debug};
@@ -140,10 +140,7 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
-    fn debug_ty(
-        ty: &Ty<Self>,
-        fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result>;
+    fn debug_ty(ty: &Ty<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result>;
 
     /// Create an "interned" type from `ty`. This is not normally
     /// invoked directly; instead, you invoke `TyData::intern` (which
@@ -285,10 +282,7 @@ mod default {
             tls::with_current_program(|prog| Some(prog?.debug_alias(alias, fmt)))
         }
 
-        fn debug_ty(
-            alias: &Ty<ChalkIr>,
-            fmt: &mut fmt::Formatter<'_>,
-        ) -> Option<fmt::Result> {
+        fn debug_ty(alias: &Ty<ChalkIr>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
             tls::with_current_program(|prog| Some(prog?.debug_ty(alias, fmt)))
         }
 

chalk-ir/src/tls.rs

@@ -1,5 +1,5 @@
 use crate::interner::ChalkIr;
-use crate::{AliasTy, AssocTypeId, Ty, StructId, TraitId};
+use crate::{AliasTy, AssocTypeId, StructId, TraitId, Ty};
 use std::cell::RefCell;
 use std::fmt;
 use std::sync::Arc;
@@ -33,11 +33,7 @@ pub trait DebugContext {
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error>;
 
-    fn debug_ty(
-        &self,
-        ty: &Ty<ChalkIr>,
-        fmt: &mut fmt::Formatter<'_>,
-    ) -> Result<(), fmt::Error>;
+    fn debug_ty(&self, ty: &Ty<ChalkIr>, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error>;
 }
 
 pub fn with_current_program<R>(op: impl FnOnce(Option<&Arc<dyn DebugContext>>) -> R) -> R {

chalk-solve/src/clauses.rs

@@ -227,8 +227,7 @@ fn program_clauses_that_could_match<I: Interner>(
                     // ```
                     // forall<'a> { Implemented(dyn Fn(&u8): Fn<(&'a u8)>) }
                     // ```
-                    let qwc = exists_qwc
-                        .substitute(interner, &[self_ty.clone().cast(interner)]);
+                    let qwc = exists_qwc.substitute(interner, &[self_ty.clone().cast(interner)]);
 
                     builder.push_binders(&qwc, |builder, wc| {
                         builder.push_fact(wc);

chalk-solve/src/infer/unify.rs

@@ -208,17 +208,13 @@ impl<'t, I: Interner> Unifier<'t, I> {
 
         {
             let a_universal = self.table.instantiate_binders_universally(interner, a);
-            let b_existential = self
-                .table
-                .instantiate_binders_existentially(interner, b);
+            let b_existential = self.table.instantiate_binders_existentially(interner, b);
             Zip::zip_with(self, &a_universal, &b_existential)?;
         }
 
         {
             let b_universal = self.table.instantiate_binders_universally(interner, b);
-            let a_existential = self
-                .table
-                .instantiate_binders_existentially(interner, a);
+            let a_existential = self.table.instantiate_binders_existentially(interner, a);
             Zip::zip_with(self, &a_existential, &b_universal)
         }
     }

chalk-solve/src/solve/slg.rs

@@ -337,7 +337,6 @@ impl<'me, I: Interner> context::ContextOps<SlgContext<I>> for SlgContextOps<'me,
         let interner = self.interner();
         u_canon.is_trivial_substitution(interner, canonical_subst)
     }
-
 }
 
 impl<I: Interner> TruncatingInferenceTable<I> {
@@ -502,7 +501,7 @@ impl<I: Interner> SubstitutionExt<I> for Substitution<I> {
     fn may_invalidate(&self, interner: &I, subst: &Canonical<Substitution<I>>) -> bool {
         self.iter()
             .zip(subst.value.iter())
-            .any(|(new, current)| MayInvalidate{ interner }.aggregate_parameters( new, current))
+            .any(|(new, current)| MayInvalidate { interner }.aggregate_parameters(new, current))
     }
 }
 
@@ -512,11 +511,7 @@ struct MayInvalidate<'i, I> {
 }
 
 impl<I: Interner> MayInvalidate<'_, I> {
-    fn aggregate_parameters(
-        &mut self,
-        new: &Parameter<I>,
-        current: &Parameter<I>,
-    ) -> bool {
+    fn aggregate_parameters(&mut self, new: &Parameter<I>, current: &Parameter<I>) -> bool {
         match (new.data(), current.data()) {
             (ParameterKind::Ty(ty1), ParameterKind::Ty(ty2)) => self.aggregate_tys(ty1, ty2),
             (ParameterKind::Lifetime(l1), ParameterKind::Lifetime(l2)) => {
@@ -667,6 +662,6 @@ impl<I: Interner> MayInvalidate<'_, I> {
         new_substitution
             .iter()
             .zip(current_substitution)
-            .any(|(new, current)| self.aggregate_parameters( new, current))
+            .any(|(new, current)| self.aggregate_parameters(new, current))
     }
 }