cargo fmt

Author: tirr-c

chalk-engine/src/context.rs

@@ -178,11 +178,7 @@ pub trait ContextOps<C: Context>: Sized + Clone + Debug + AggregateOps<C> {
     ) -> Result<Vec<C::ProgramClause>, Floundered>;
 
     // Used by: simplify
-    fn add_clauses(
-        &self,
-        env: &C::Environment,
-        clauses: C::ProgramClauses,
-    ) -> C::Environment;
+    fn add_clauses(&self, env: &C::Environment, clauses: C::ProgramClauses) -> C::Environment;
 
     /// Create an inference table for processing a new goal and instantiate that goal
     /// in that context, returning "all the pieces".

chalk-integration/src/lowering.rs

@@ -1307,7 +1307,8 @@ impl<'k> LowerGoal<Env<'k>> for Goal {
                     .into_iter()
                     .flat_map(|h| h.lower_clause(env).apply_result())
                     .map(|result| result.map(|h| h.into_from_env_clause(interner)));
-                let where_clauses = chalk_ir::ProgramClauses::from_fallible(interner, where_clauses);
+                let where_clauses =
+                    chalk_ir::ProgramClauses::from_fallible(interner, where_clauses);
                 Ok(chalk_ir::GoalData::Implies(where_clauses?, g.lower(env)?).intern(interner))
             }
             Goal::And(g1, g2s) => {

chalk-ir/src/could_match.rs

@@ -69,7 +69,9 @@ impl<I: Interner> CouldMatch<DomainGoal<I>> for ProgramClauseData<I> {
                 implication.consequence.could_match(interner, other)
             }
 
-            ProgramClauseData::ForAll(clause) => clause.value.consequence.could_match(interner, other),
+            ProgramClauseData::ForAll(clause) => {
+                clause.value.consequence.could_match(interner, other)
+            }
         }
     }
 }

chalk-ir/src/debug.rs

@@ -60,8 +60,7 @@ impl<I: Interner> Debug for ProgramClauseImplication<I> {
 
 impl<I: Interner> Debug for ProgramClause<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_program_clause(self, fmt)
-            .unwrap_or_else(|| write!(fmt, "{:?}", self.clause))
+        I::debug_program_clause(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.clause))
     }
 }
 

chalk-ir/src/fold/boring_impls.rs

@@ -259,12 +259,12 @@ impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClauseData<
         TI: 'i,
     {
         match self {
-            ProgramClauseData::Implies(pci) => {
-                Ok(ProgramClauseData::Implies(pci.fold_with(folder, outer_binder)?))
-            }
-            ProgramClauseData::ForAll(pci) => {
-                Ok(ProgramClauseData::ForAll(pci.fold_with(folder, outer_binder)?))
-            }
+            ProgramClauseData::Implies(pci) => Ok(ProgramClauseData::Implies(
+                pci.fold_with(folder, outer_binder)?,
+            )),
+            ProgramClauseData::ForAll(pci) => Ok(ProgramClauseData::ForAll(
+                pci.fold_with(folder, outer_binder)?,
+            )),
         }
     }
 }
@@ -280,7 +280,9 @@ impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClause<I> {
         TI: 'i,
     {
         let clause = self.data(folder.interner());
-        Ok(clause.super_fold_with(folder, outer_binder)?.intern(folder.target_interner()))
+        Ok(clause
+            .super_fold_with(folder, outer_binder)?
+            .intern(folder.target_interner()))
     }
 }
 

chalk-ir/src/interner.rs

@@ -637,10 +637,7 @@ mod default {
             substitution
         }
 
-        fn intern_program_clause(
-            &self,
-            data: ProgramClauseData<Self>,
-        ) -> ProgramClauseData<Self> {
+        fn intern_program_clause(&self, data: ProgramClauseData<Self>) -> ProgramClauseData<Self> {
             data
         }
 

chalk-ir/src/lib.rs

@@ -53,15 +53,18 @@ pub struct Environment<I: Interner> {
 
 impl<I: Interner> Environment<I> {
     pub fn new(interner: &I) -> Self {
-        Environment { clauses: ProgramClauses::new(interner) }
+        Environment {
+            clauses: ProgramClauses::new(interner),
+        }
     }
 
     pub fn add_clauses<II>(&self, interner: &I, clauses: II) -> Self
     where
         II: IntoIterator<Item = ProgramClause<I>>,
     {
         let mut env = self.clone();
-        env.clauses = ProgramClauses::from(interner, env.clauses.iter(interner).cloned().chain(clauses));
+        env.clauses =
+            ProgramClauses::from(interner, env.clauses.iter(interner).cloned().chain(clauses));
         env
     }
 }
@@ -1233,9 +1236,9 @@ impl<I: Interner> ProgramClauseData<I> {
             ProgramClauseData::Implies(implication) => {
                 ProgramClauseData::Implies(implication.into_from_env_clause(interner))
             }
-            ProgramClauseData::ForAll(binders_implication) => {
-                ProgramClauseData::ForAll(binders_implication.map(|i| i.into_from_env_clause(interner)))
-            }
+            ProgramClauseData::ForAll(binders_implication) => ProgramClauseData::ForAll(
+                binders_implication.map(|i| i.into_from_env_clause(interner)),
+            ),
         }
     }
 
@@ -1279,7 +1282,10 @@ impl<I: Interner> ProgramClauses<I> {
         &self.clauses
     }
 
-    pub fn from(interner: &I, clauses: impl IntoIterator<Item = impl CastTo<ProgramClause<I>>>) -> Self {
+    pub fn from(
+        interner: &I,
+        clauses: impl IntoIterator<Item = impl CastTo<ProgramClause<I>>>,
+    ) -> Self {
         use crate::cast::Caster;
         ProgramClauses {
             clauses: I::intern_program_clauses(interner, clauses.into_iter().casted(interner)),
@@ -1462,10 +1468,7 @@ impl<I: Interner> Goal<I> {
                 GoalData::Implies(
                     ProgramClauses::from(
                         interner,
-                        vec![
-                            DomainGoal::Compatible(()),
-                            DomainGoal::DownstreamType(ty),
-                        ],
+                        vec![DomainGoal::Compatible(()), DomainGoal::DownstreamType(ty)],
                     ),
                     self.shifted_in(interner),
                 )

chalk-ir/src/zip.rs

@@ -252,7 +252,11 @@ impl<I: Interner> Zip<I> for Environment<I> {
     {
         let interner = zipper.interner();
         assert_eq!(a.clauses.len(interner), b.clauses.len(interner)); // or different numbers of clauses
-        Zip::zip_with(zipper, a.clauses.as_slice(interner), b.clauses.as_slice(interner))?;
+        Zip::zip_with(
+            zipper,
+            a.clauses.as_slice(interner),
+            b.clauses.as_slice(interner),
+        )?;
         Ok(())
     }
 }

chalk-solve/src/clauses.rs

@@ -397,7 +397,11 @@ fn program_clauses_for_env<'db, I: Interner>(
     clauses: &mut Vec<ProgramClause<I>>,
 ) {
     let mut last_round = FxHashSet::default();
-    elaborate_env_clauses(db, environment.clauses.as_slice(db.interner()), &mut last_round);
+    elaborate_env_clauses(
+        db,
+        environment.clauses.as_slice(db.interner()),
+        &mut last_round,
+    );
 
     let mut closure = last_round.clone();
     let mut next_round = FxHashSet::default();

chalk-solve/src/clauses/builder.rs

@@ -51,12 +51,16 @@ impl<'me, I: Interner> ClauseBuilder<'me, I> {
         };
 
         if self.binders.len() == 0 {
-            self.clauses.push(ProgramClauseData::Implies(clause).intern(interner));
+            self.clauses
+                .push(ProgramClauseData::Implies(clause).intern(interner));
         } else {
-            self.clauses.push(ProgramClauseData::ForAll(Binders {
-                binders: self.binders.clone(),
-                value: clause,
-            }).intern(interner));
+            self.clauses.push(
+                ProgramClauseData::ForAll(Binders {
+                    binders: self.binders.clone(),
+                    value: clause,
+                })
+                .intern(interner),
+            );
         }
 
         debug!("pushed clause {:?}", self.clauses.last());