Refactor & cleanup

Author: iDawer

crates/hir-ty/src/infer.rs

@@ -63,18 +63,13 @@ pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<Infer
     let body = db.body(def);
     let mut ctx = InferenceContext::new(db, def, &body, resolver);
 
-    crate::tls::set_current_program(db, || {
-        match def {
-            DefWithBodyId::ConstId(c) => ctx.collect_const(&db.const_data(c)),
-            DefWithBodyId::FunctionId(f) => {
-                eprintln!();
-                ctx.collect_fn(f);
-            }
-            DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_data(s)),
-        }
+    match def {
+        DefWithBodyId::ConstId(c) => ctx.collect_const(&db.const_data(c)),
+        DefWithBodyId::FunctionId(f) => ctx.collect_fn(f),
+        DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_data(s)),
+    }
 
-        ctx.infer_body();
-    });
+    ctx.infer_body();
 
     Arc::new(ctx.resolve_all())
 }
@@ -481,46 +476,41 @@ impl<'a> InferenceContext<'a> {
         } else {
             &*data.ret_type
         };
-        // let return_ty = dbg!(self.make_ty_with_mode(return_ty, ImplTraitLoweringMode::Disallowed)); // FIXME implement RPIT
         let return_ty = self.make_ty_with_mode(return_ty, ImplTraitLoweringMode::Opaque);
         self.return_ty = return_ty;
 
-        if let Some(rpits) = dbg!(self.db.return_type_impl_traits(func)) {
-            let mut rpit_vars = Vec::new();
+        if let Some(rpits) = self.db.return_type_impl_traits(func) {
             // RPIT opaque types use substitution of their parent function.
-            let fn_placeholders = dbg!(TyBuilder::placeholder_subst(self.db, func));
-            let rpits = dbg!((&*rpits).clone().substitute(Interner, &fn_placeholders));
-            for rpit in rpits.impl_traits {
-                let var = self.table.new_type_var();
-                rpit_vars.push(var.clone());
-                let self_var = Substitution::from1(Interner, var);
-                for predicate in dbg!(rpit.bounds.substitute(Interner, &self_var)) {
-                    let (predicate, binders) = predicate.into_value_and_skipped_binders();
-                    always!(binders.len(Interner) == 0); // quantified where clauses not yet handled
-                    self.push_obligation(predicate.cast(Interner));
-                }
-            }
-
+            let fn_placeholders = TyBuilder::placeholder_subst(self.db, func);
             self.return_ty = fold_tys(
-                dbg!(self.return_ty.clone()),
-                |ty, _outer_binder| match *ty.kind(Interner) {
-                    TyKind::OpaqueType(opaque_ty_id, _) => {
-                        let impl_trait_id =
-                            self.db.lookup_intern_impl_trait_id(opaque_ty_id.into());
-                        match impl_trait_id {
-                            ImplTraitId::ReturnTypeImplTrait(_, idx) => {
-                                rpit_vars[idx as usize].clone()
-                            }
-                            _ => unreachable!(),
-                        }
+                self.return_ty.clone(),
+                |ty, _| {
+                    let opaque_ty_id = match ty.kind(Interner) {
+                        TyKind::OpaqueType(opaque_ty_id, _) => *opaque_ty_id,
+                        _ => return ty,
+                    };
+                    let idx = match self.db.lookup_intern_impl_trait_id(opaque_ty_id.into()) {
+                        ImplTraitId::ReturnTypeImplTrait(_, idx) => idx,
+                        _ => unreachable!(),
+                    };
+                    let bounds = (*rpits).map_ref(|rpits| {
+                        rpits.impl_traits[idx as usize].bounds.map_ref(|it| it.into_iter())
+                    });
+                    let var = self.table.new_type_var();
+                    let self_var = Substitution::from1(Interner, var.clone());
+                    for bound in bounds {
+                        let predicate =
+                            bound.map(|it| it.cloned()).substitute(Interner, &fn_placeholders);
+                        let (var_predicate, binders) = predicate
+                            .substitute(Interner, &self_var)
+                            .into_value_and_skipped_binders();
+                        always!(binders.len(Interner) == 0); // quantified where clauses not yet handled
+                        self.push_obligation(var_predicate.cast(Interner));
                     }
-                    _ => ty,
+                    var
                 },
                 DebruijnIndex::INNERMOST,
             );
-            dbg!(&self.return_ty);
-            dbg!(&self.table);
-            compile_error!("skip ci build");
         }
     }
 

crates/hir-ty/src/infer/unify.rs

@@ -623,10 +623,7 @@ impl<'a> InferenceTable<'a> {
 
 impl<'a> fmt::Debug for InferenceTable<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("InferenceTable")
-            .field("num_vars", &self.type_variable_table.len())
-            .field("pending_obligations", &self.pending_obligations)
-            .finish()
+        f.debug_struct("InferenceTable").field("num_vars", &self.type_variable_table.len()).finish()
     }
 }
 

crates/hir-ty/src/lib.rs

@@ -522,27 +522,3 @@ where
     });
     Canonical { value, binders: chalk_ir::CanonicalVarKinds::from_iter(Interner, kinds) }
 }
-
-impl Fold<Interner> for ReturnTypeImplTrait {
-    type Result = ReturnTypeImplTrait;
-
-    fn fold_with<E>(
-        self,
-        folder: &mut dyn chalk_ir::fold::Folder<Interner, Error = E>,
-        outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
-        Ok(ReturnTypeImplTrait { bounds: self.bounds.fold_with(folder, outer_binder)? })
-    }
-}
-
-impl Fold<Interner> for ReturnTypeImplTraits {
-    type Result = ReturnTypeImplTraits;
-
-    fn fold_with<E>(
-        self,
-        folder: &mut dyn chalk_ir::fold::Folder<Interner, Error = E>,
-        outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
-        Ok(ReturnTypeImplTraits { impl_traits: self.impl_traits.fold_with(folder, outer_binder)? })
-    }
-}

crates/hir-ty/src/tests/traits.rs

@@ -1281,30 +1281,6 @@ fn foo<const C: u8, T>() -> (impl FnOnce(&str, T), impl Trait<u8>) {
     );
 }
 
-#[test]
-fn playground() {
-    check_infer_with_mismatches(
-        r#"
-//- minicore: fn, sized, iterator
-trait Trait<T> {}
-struct Bar<T>(T);
-impl<T> Trait<T> for Bar<T> {}
-struct Foo<F>;
-impl<F> Foo<F> {
-    fn foo<const C: u8, T: Trait<T>, U>(t: T) -> (T, impl Fn(T), impl Trait<u8>) {
-        (t, |input| {}, Bar(C))
-    }
-}
-// fn bar() {
-//     struct Bar;
-//     foo::<1, Bar>(Bar);
-// }
-fn qwe<const C: u8, T, U>() -> impl Iterator<Item = impl Trait<u8>> {}
-"#,
-        expect![[]],
-    );
-}
-
 #[test]
 fn dyn_trait() {
     check_infer(