fmt and add gat test

Author: basil-cow

chalk-integration/src/lowering.rs

@@ -140,7 +140,6 @@ impl<'k> Env<'k> {
         Err(RustIrError::InvalidConstName(name))
     }
 
-
     fn struct_kind(&self, id: chalk_ir::StructId<ChalkIr>) -> &TypeKind {
         &self.struct_kinds[&id]
     }
@@ -703,7 +702,7 @@ impl LowerLeafGoal for LeafGoal {
                 a: a.lower(env)?.cast(interner),
                 b: b.lower(env)?.cast(interner),
             }
-            .cast::<chalk_ir::Goal<ChalkIr>>(interner)
+            .cast::<chalk_ir::Goal<ChalkIr>>(interner),
         })
     }
 }
@@ -1120,19 +1119,20 @@ impl LowerParameter for Parameter {
 }
 
 trait LowerConst {
-    fn lower(&self, env: &Env) -> LowerResult<chalk_ir::Const<ChalkIr>>; 
+    fn lower(&self, env: &Env) -> LowerResult<chalk_ir::Const<ChalkIr>>;
 }
 
 impl LowerConst for Const {
     fn lower(&self, env: &Env) -> LowerResult<chalk_ir::Const<ChalkIr>> {
         let interner = env.interner();
         match *self {
             Const::Id { name } => match env.lookup_const(name)? {
-                ConstLookup::Parameter(d) => {
-                    Ok(chalk_ir::ConstData::BoundVar(d).intern(interner))
-                }
+                ConstLookup::Parameter(d) => Ok(chalk_ir::ConstData::BoundVar(d).intern(interner)),
             },
-            Const::Value{ value } => Ok(chalk_ir::ConstData::Evaluated(chalk_ir::ConstEvaluated { interned: value }).intern(interner))
+            Const::Value { value } => Ok(chalk_ir::ConstData::Evaluated(
+                chalk_ir::ConstEvaluated { interned: value },
+            )
+            .intern(interner)),
         }
     }
 }

chalk-ir/src/debug.rs

@@ -41,11 +41,10 @@ impl<I: Interner> Debug for Const<I> {
 
 impl<I: Interner> Debug for ConstEvaluated<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(fmt, "{:?}", self.interned) 
+        write!(fmt, "{:?}", self.interned)
     }
 }
 
-
 impl<I: Interner> Debug for Parameter<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         I::debug_parameter(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.interned))

chalk-ir/src/fold/shift.rs

@@ -98,10 +98,7 @@ impl<'i, I: Interner> Folder<'i, I> for Shifter<'i, I> {
         bound_var: BoundVar,
         outer_binder: DebruijnIndex,
     ) -> Fallible<Const<I>> {
-        Ok(
-            ConstData::<I>::BoundVar(self.adjust(bound_var, outer_binder))
-                .intern(self.interner()),
-        )
+        Ok(ConstData::<I>::BoundVar(self.adjust(bound_var, outer_binder)).intern(self.interner()))
     }
 
     fn interner(&self) -> &'i I {
@@ -169,10 +166,7 @@ impl<'i, I: Interner> Folder<'i, I> for DownShifter<'i, I> {
         bound_var: BoundVar,
         outer_binder: DebruijnIndex,
     ) -> Fallible<Const<I>> {
-        Ok(
-            ConstData::<I>::BoundVar(self.adjust(bound_var, outer_binder)?)
-                .intern(self.interner()),
-        )
+        Ok(ConstData::<I>::BoundVar(self.adjust(bound_var, outer_binder)?).intern(self.interner()))
     }
 
     fn interner(&self) -> &'i I {

chalk-parse/src/ast.rs

@@ -88,7 +88,7 @@ pub enum ParameterKind {
 pub enum Parameter {
     Ty(Ty),
     Lifetime(Lifetime),
-    Const(Const)
+    Const(Const),
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]

chalk-solve/src/infer/canonicalize.rs

@@ -222,10 +222,7 @@ where
                 let free_var = ParameterKind::Const(self.table.unify.find(var));
                 let bound_var = BoundVar::new(DebruijnIndex::INNERMOST, self.add(free_var));
                 debug!("not yet unified: position={:?}", bound_var);
-                Ok(
-                    ConstData::BoundVar(bound_var.shifted_in_from(outer_binder))
-                        .intern(interner),
-                )
+                Ok(ConstData::BoundVar(bound_var.shifted_in_from(outer_binder)).intern(interner))
             }
         }
     }

tests/test/projection.rs

@@ -232,6 +232,49 @@ fn normalize_gat2() {
     }
 }
 
+#[test]
+fn normalize_gat_const() {
+    test! {
+        program {
+            trait StreamingIterator<T> { type Item<$N>; }
+            struct Span<$N, T> { }
+            struct StreamIterMut<T> { }
+            struct u32 { }
+            impl<T> StreamingIterator<T> for StreamIterMut<T> {
+                type Item<$N> = Span<$N, T>;
+            }
+        }
+
+        goal {
+            forall<$N, T> {
+                exists<U> {
+                    Normalize(<StreamIterMut<T> as StreamingIterator<T>>::Item<$N> -> U)
+                }
+            }
+        } yields {
+            "Unique; substitution [?0 := Span<!1_0, !1_1>], lifetime constraints []"
+        }
+
+        goal {
+            forall<$N, T> {
+                <StreamIterMut<T> as StreamingIterator<T>>::Item<$N> = Span<$N, T>
+            }
+        } yields {
+            "Unique; substitution [], lifetime constraints []"
+        }
+
+        goal {
+            forall<$N, T, U> {
+                if (T: StreamingIterator<U, Item<$N> = Span<$N, U>>) {
+                    <T as StreamingIterator<U>>::Item<$N> = Span<$N, U>
+                }
+            }
+        } yields {
+            "Unique; substitution [], lifetime constraints []"
+        }
+    }
+}
+
 #[test]
 fn normalize_gat_with_where_clause() {
     test! {