23 files changed, 155 insertions, 128 deletions

diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index b3af82444..06714409f 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -130,7 +130,7 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
     ) -> chalk_ir::ProgramClauses<chalk::Interner>;
 }
 
-fn infer_wait(db: &impl HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
+fn infer_wait(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
     let _p = profile::span("infer:wait").detail(|| match def {
         DefWithBodyId::FunctionId(it) => db.function_data(it).name.to_string(),
         DefWithBodyId::StaticId(it) => {
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index 6773ddea3..3605ca581 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -28,7 +28,6 @@ use syntax::{
     ast::{self, NameOwner},
     AstNode, AstPtr,
 };
-use test_utils::mark;
 
 use crate::{
     db::HirDatabase,
@@ -93,16 +92,21 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
     fn validate_func(&mut self, func: FunctionId) {
         let data = self.db.function_data(func);
         if data.is_extern {
-            mark::hit!(extern_func_incorrect_case_ignored);
+            cov_mark::hit!(extern_func_incorrect_case_ignored);
             return;
         }
 
         let body = self.db.body(func.into());
 
         // Recursively validate inner scope items, such as static variables and constants.
-        for (item_id, _) in body.item_scope.values() {
-            let mut validator = DeclValidator::new(self.db, self.krate, self.sink);
-            validator.validate_item(item_id);
+        let db = self.db;
+        for block_def_map in body.block_scopes.iter().filter_map(|block| db.block_def_map(*block)) {
+            for (_, module) in block_def_map.modules() {
+                for (def_id, _) in module.scope.values() {
+                    let mut validator = DeclValidator::new(self.db, self.krate, self.sink);
+                    validator.validate_item(def_id);
+                }
+            }
         }
 
         // Check whether non-snake case identifiers are allowed for this function.
@@ -625,7 +629,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
     fn validate_static(&mut self, static_id: StaticId) {
         let data = self.db.static_data(static_id);
         if data.is_extern {
-            mark::hit!(extern_static_incorrect_case_ignored);
+            cov_mark::hit!(extern_static_incorrect_case_ignored);
             return;
         }
 
@@ -673,8 +677,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
 
 #[cfg(test)]
 mod tests {
-    use test_utils::mark;
-
     use crate::diagnostics::tests::check_diagnostics;
 
     #[test]
@@ -889,8 +891,8 @@ fn main() {
 
     #[test]
     fn ignores_extern_items() {
-        mark::check!(extern_func_incorrect_case_ignored);
-        mark::check!(extern_static_incorrect_case_ignored);
+        cov_mark::check!(extern_func_incorrect_case_ignored);
+        cov_mark::check!(extern_static_incorrect_case_ignored);
         check_diagnostics(
             r#"
 extern {
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 66a88e2b6..2751cd304 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -2,9 +2,7 @@
 
 use std::sync::Arc;
 
-use hir_def::{
-    expr::Statement, path::path, resolver::HasResolver, AdtId, AssocItemId, DefWithBodyId,
-};
+use hir_def::{expr::Statement, path::path, resolver::HasResolver, AssocItemId, DefWithBodyId};
 use hir_expand::{diagnostics::DiagnosticSink, name};
 use rustc_hash::FxHashSet;
 use syntax::{ast, AstPtr};
@@ -17,7 +15,7 @@ use crate::{
         MissingPatFields, RemoveThisSemicolon,
     },
     utils::variant_data,
-    InferenceResult, Ty,
+    AdtId, InferenceResult, Ty,
 };
 
 pub(crate) use hir_def::{
@@ -382,10 +380,14 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         };
 
         let (params, required) = match mismatch.expected {
-            Ty::Adt(AdtId::EnumId(enum_id), ref parameters) if enum_id == core_result_enum => {
+            Ty::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters)
+                if enum_id == core_result_enum =>
+            {
                 (parameters, "Ok".to_string())
             }
-            Ty::Adt(AdtId::EnumId(enum_id), ref parameters) if enum_id == core_option_enum => {
+            Ty::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters)
+                if enum_id == core_option_enum =>
+            {
                 (parameters, "Some".to_string())
             }
             _ => return,
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index 86fee0050..04d39c571 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -222,12 +222,12 @@ use hir_def::{
     adt::VariantData,
     body::Body,
     expr::{Expr, Literal, Pat, PatId},
-    AdtId, EnumVariantId, StructId, VariantId,
+    EnumVariantId, StructId, VariantId,
 };
 use la_arena::Idx;
 use smallvec::{smallvec, SmallVec};
 
-use crate::{db::HirDatabase, InferenceResult, Ty};
+use crate::{db::HirDatabase, AdtId, InferenceResult, Ty};
 
 #[derive(Debug, Clone, Copy)]
 /// Either a pattern from the source code being analyzed, represented as
@@ -627,7 +627,7 @@ pub(super) fn is_useful(
     // - `!` type
     // In those cases, no match arm is useful.
     match cx.infer[cx.match_expr].strip_references() {
-        Ty::Adt(AdtId::EnumId(enum_id), ..) => {
+        Ty::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ..) => {
             if cx.db.enum_data(*enum_id).variants.is_empty() {
                 return Ok(Usefulness::NotUseful);
             }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index d4a8b48e6..ab51cb0a6 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -2,19 +2,20 @@
 
 use std::{borrow::Cow, fmt};
 
-use crate::{
-    db::HirDatabase, primitive, utils::generics, AliasTy, CallableDefId, CallableSig,
-    GenericPredicate, Lifetime, Obligation, OpaqueTy, OpaqueTyId, ProjectionTy, Scalar, Substs,
-    TraitRef, Ty,
-};
 use arrayvec::ArrayVec;
 use chalk_ir::Mutability;
 use hir_def::{
-    db::DefDatabase, find_path, generics::TypeParamProvenance, item_scope::ItemInNs, AdtId,
-    AssocContainerId, HasModule, Lookup, ModuleId, TraitId,
+    db::DefDatabase, find_path, generics::TypeParamProvenance, item_scope::ItemInNs,
+    AssocContainerId, Lookup, ModuleId, TraitId,
 };
 use hir_expand::name::Name;
 
+use crate::{
+    db::HirDatabase, primitive, utils::generics, AdtId, AliasTy, CallableDefId, CallableSig,
+    GenericPredicate, Lifetime, Obligation, OpaqueTy, OpaqueTyId, ProjectionTy, Scalar, Substs,
+    TraitRef, Ty,
+};
+
 pub struct HirFormatter<'a> {
     pub db: &'a dyn HirDatabase,
     fmt: &'a mut dyn fmt::Write,
@@ -400,13 +401,13 @@ impl HirDisplay for Ty {
                     write!(f, " -> {}", ret_display)?;
                 }
             }
-            Ty::Adt(def_id, parameters) => {
+            Ty::Adt(AdtId(def_id), parameters) => {
                 match f.display_target {
                     DisplayTarget::Diagnostics | DisplayTarget::Test => {
                         let name = match *def_id {
-                            AdtId::StructId(it) => f.db.struct_data(it).name.clone(),
-                            AdtId::UnionId(it) => f.db.union_data(it).name.clone(),
-                            AdtId::EnumId(it) => f.db.enum_data(it).name.clone(),
+                            hir_def::AdtId::StructId(it) => f.db.struct_data(it).name.clone(),
+                            hir_def::AdtId::UnionId(it) => f.db.union_data(it).name.clone(),
+                            hir_def::AdtId::EnumId(it) => f.db.enum_data(it).name.clone(),
                         };
                         write!(f, "{}", name)?;
                     }
@@ -610,7 +611,7 @@ impl HirDisplay for CallableSig {
 }
 
 fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = TraitId> {
-    let krate = trait_.lookup(db).container.module(db).krate();
+    let krate = trait_.lookup(db).container.krate();
     let fn_traits = [
         db.lang_item(krate, "fn".into()),
         db.lang_item(krate, "fn_mut".into()),
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index cf0a3add4..7e8846f27 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -6,7 +6,6 @@
 
 use chalk_ir::{Mutability, TyVariableKind};
 use hir_def::lang_item::LangItemTarget;
-use test_utils::mark;
 
 use crate::{autoderef, traits::Solution, Obligation, Substs, TraitRef, Ty};
 
@@ -35,7 +34,7 @@ impl<'a> InferenceContext<'a> {
             ty1.clone()
         } else {
             if let (Ty::FnDef(..), Ty::FnDef(..)) = (ty1, ty2) {
-                mark::hit!(coerce_fn_reification);
+                cov_mark::hit!(coerce_fn_reification);
                 // Special case: two function types. Try to coerce both to
                 // pointers to have a chance at getting a match. See
                 // https://github.com/rust-lang/rust/blob/7b805396bf46dce972692a6846ce2ad8481c5f85/src/librustc_typeck/check/coercion.rs#L877-L916
@@ -45,7 +44,7 @@ impl<'a> InferenceContext<'a> {
                 let ptr_ty2 = Ty::fn_ptr(sig2);
                 self.coerce_merge_branch(&ptr_ty1, &ptr_ty2)
             } else {
-                mark::hit!(coerce_merge_fail_fallback);
+                cov_mark::hit!(coerce_merge_fail_fallback);
                 ty1.clone()
             }
         }
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index cf1f1038a..262177ffb 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -8,11 +8,10 @@ use hir_def::{
     expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
     path::{GenericArg, GenericArgs},
     resolver::resolver_for_expr,
-    AdtId, AssocContainerId, FieldId, Lookup,
+    AssocContainerId, FieldId, Lookup,
 };
 use hir_expand::name::{name, Name};
 use syntax::ast::RangeOp;
-use test_utils::mark;
 
 use crate::{
     autoderef,
@@ -21,8 +20,8 @@ use crate::{
     primitive::{self, UintTy},
     traits::{FnTrait, InEnvironment},
     utils::{generics, variant_data, Generics},
-    Binders, CallableDefId, FnPointer, FnSig, Obligation, OpaqueTyId, Rawness, Scalar, Substs,
-    TraitRef, Ty,
+    AdtId, Binders, CallableDefId, FnPointer, FnSig, Obligation, OpaqueTyId, Rawness, Scalar,
+    Substs, TraitRef, Ty,
 };
 
 use super::{
@@ -429,14 +428,14 @@ impl<'a> InferenceContext<'a> {
                     Ty::Tuple(_, substs) => {
                         name.as_tuple_index().and_then(|idx| substs.0.get(idx).cloned())
                     }
-                    Ty::Adt(AdtId::StructId(s), parameters) => {
+                    Ty::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => {
                         self.db.struct_data(s).variant_data.field(name).map(|local_id| {
                             let field = FieldId { parent: s.into(), local_id };
                             self.write_field_resolution(tgt_expr, field);
                             self.db.field_types(s.into())[field.local_id].clone().subst(&parameters)
                         })
                     }
-                    Ty::Adt(AdtId::UnionId(u), parameters) => {
+                    Ty::Adt(AdtId(hir_def::AdtId::UnionId(u)), parameters) => {
                         self.db.union_data(u).variant_data.field(name).map(|local_id| {
                             let field = FieldId { parent: u.into(), local_id };
                             self.write_field_resolution(tgt_expr, field);
@@ -498,7 +497,7 @@ impl<'a> InferenceContext<'a> {
                         _ => (),
                     }
                     sb = sb.fill(repeat_with(|| self.table.new_type_var()));
-                    Ty::Adt(box_, sb.build())
+                    Ty::adt_ty(box_, sb.build())
                 } else {
                     Ty::Unknown
                 }
@@ -565,7 +564,7 @@ impl<'a> InferenceContext<'a> {
                     let ret = op::binary_op_return_ty(*op, lhs_ty.clone(), rhs_ty.clone());
 
                     if ret == Ty::Unknown {
-                        mark::hit!(infer_expr_inner_binary_operator_overload);
+                        cov_mark::hit!(infer_expr_inner_binary_operator_overload);
 
                         self.resolve_associated_type_with_params(
                             lhs_ty,
@@ -586,31 +585,31 @@ impl<'a> InferenceContext<'a> {
                 let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect));
                 match (range_type, lhs_ty, rhs_ty) {
                     (RangeOp::Exclusive, None, None) => match self.resolve_range_full() {
-                        Some(adt) => Ty::Adt(adt, Substs::empty()),
+                        Some(adt) => Ty::adt_ty(adt, Substs::empty()),
                         None => Ty::Unknown,
                     },
                     (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {
-                        Some(adt) => Ty::Adt(adt, Substs::single(ty)),
+                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
                         None => Ty::Unknown,
                     },
                     (RangeOp::Inclusive, None, Some(ty)) => {
                         match self.resolve_range_to_inclusive() {
-                            Some(adt) => Ty::Adt(adt, Substs::single(ty)),
+                            Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
                             None => Ty::Unknown,
                         }
                     }
                     (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {
-                        Some(adt) => Ty::Adt(adt, Substs::single(ty)),
+                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
                         None => Ty::Unknown,
                     },
                     (RangeOp::Inclusive, Some(_), Some(ty)) => {
                         match self.resolve_range_inclusive() {
-                            Some(adt) => Ty::Adt(adt, Substs::single(ty)),
+                            Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
                             None => Ty::Unknown,
                         }
                     }
                     (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {
-                        Some(adt) => Ty::Adt(adt, Substs::single(ty)),
+                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
                         None => Ty::Unknown,
                     },
                     (RangeOp::Inclusive, _, None) => Ty::Unknown,
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index eb099311c..a0ac8d80f 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -10,7 +10,6 @@ use hir_def::{
     FieldId,
 };
 use hir_expand::name::Name;
-use test_utils::mark;
 
 use super::{BindingMode, Expectation, InferenceContext};
 use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Substs, Ty};
@@ -108,7 +107,7 @@ impl<'a> InferenceContext<'a> {
                 }
             }
         } else if let Pat::Ref { .. } = &body[pat] {
-            mark::hit!(match_ergonomics_ref);
+            cov_mark::hit!(match_ergonomics_ref);
             // When you encounter a `&pat` pattern, reset to Move.
             // This is so that `w` is by value: `let (_, &w) = &(1, &2);`
             default_bm = BindingMode::Move;
@@ -237,7 +236,7 @@ impl<'a> InferenceContext<'a> {
                     };
 
                     let inner_ty = self.infer_pat(*inner, inner_expected, default_bm);
-                    Ty::Adt(box_adt, Substs::single(inner_ty))
+                    Ty::adt_ty(box_adt, Substs::single(inner_ty))
                 }
                 None => Ty::Unknown,
             },
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs
index 5d541104e..ae3554bac 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -260,7 +260,7 @@ impl<'a> InferenceContext<'a> {
                         }));
                         Some(trait_substs)
                     }
-                    AssocContainerId::ContainerId(_) => None,
+                    AssocContainerId::ModuleId(_) => None,
                 };
 
                 self.write_assoc_resolution(id, item);
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 99a89a7f3..54fcfed10 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -5,8 +5,6 @@ use std::borrow::Cow;
 use chalk_ir::{FloatTy, IntTy, TyVariableKind};
 use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 
-use test_utils::mark;
-
 use super::{InferenceContext, Obligation};
 use crate::{
     BoundVar, Canonical, DebruijnIndex, GenericPredicate, InEnvironment, InferenceVar, Scalar,
@@ -387,7 +385,7 @@ impl InferenceTable {
         // more than once
         for i in 0..3 {
             if i > 0 {
-                mark::hit!(type_var_resolves_to_int_var);
+                cov_mark::hit!(type_var_resolves_to_int_var);
             }
             match &*ty {
                 Ty::InferenceVar(tv, _) => {
@@ -416,7 +414,7 @@ impl InferenceTable {
             Ty::InferenceVar(tv, kind) => {
                 let inner = tv.to_inner();
                 if tv_stack.contains(&inner) {
-                    mark::hit!(type_var_cycles_resolve_as_possible);
+                    cov_mark::hit!(type_var_cycles_resolve_as_possible);
                     // recursive type
                     return self.type_variable_table.fallback_value(tv, kind);
                 }
@@ -443,7 +441,7 @@ impl InferenceTable {
             Ty::InferenceVar(tv, kind) => {
                 let inner = tv.to_inner();
                 if tv_stack.contains(&inner) {
-                    mark::hit!(type_var_cycles_resolve_completely);
+                    cov_mark::hit!(type_var_cycles_resolve_completely);
                     // recursive type
                     return self.type_variable_table.fallback_value(tv, kind);
                 }
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index c2a20c480..e77f24e4e 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -27,9 +27,9 @@ use std::{iter, mem, ops::Deref, sync::Arc};
 
 use base_db::salsa;
 use hir_def::{
-    builtin_type::BuiltinType, expr::ExprId, type_ref::Rawness, AdtId, AssocContainerId,
-    DefWithBodyId, FunctionId, GenericDefId, HasModule, LifetimeParamId, Lookup, TraitId,
-    TypeAliasId, TypeParamId,
+    builtin_type::BuiltinType, expr::ExprId, type_ref::Rawness, AssocContainerId, DefWithBodyId,
+    FunctionId, GenericDefId, HasModule, LifetimeParamId, Lookup, TraitId, TypeAliasId,
+    TypeParamId,
 };
 use itertools::Itertools;
 
@@ -47,7 +47,9 @@ pub use lower::{
 };
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
 
-pub use chalk_ir::{BoundVar, DebruijnIndex, Mutability, Scalar, TyVariableKind};
+pub use chalk_ir::{AdtId, BoundVar, DebruijnIndex, Mutability, Scalar, TyVariableKind};
+
+pub(crate) use crate::traits::chalk::Interner;
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Lifetime {
@@ -131,7 +133,7 @@ pub enum AliasTy {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Ty {
     /// Structures, enumerations and unions.
-    Adt(AdtId, Substs),
+    Adt(AdtId<Interner>, Substs),
 
     /// Represents an associated item like `Iterator::Item`.  This is used
     /// when we have tried to normalize a projection like `T::Item` but
@@ -602,6 +604,10 @@ impl Ty {
         Ty::Tuple(0, Substs::empty())
     }
 
+    pub fn adt_ty(adt: hir_def::AdtId, substs: Substs) -> Ty {
+        Ty::Adt(AdtId(adt), substs)
+    }
+
     pub fn fn_ptr(sig: CallableSig) -> Self {
         Ty::Function(FnPointer {
             num_args: sig.params().len(),
@@ -650,9 +656,9 @@ impl Ty {
         t
     }
 
-    pub fn as_adt(&self) -> Option<(AdtId, &Substs)> {
+    pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substs)> {
         match self {
-            Ty::Adt(adt_def, parameters) => Some((*adt_def, parameters)),
+            Ty::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),
             _ => None,
         }
     }
@@ -666,7 +672,7 @@ impl Ty {
 
     pub fn as_generic_def(&self) -> Option<GenericDefId> {
         match *self {
-            Ty::Adt(adt, ..) => Some(adt.into()),
+            Ty::Adt(AdtId(adt), ..) => Some(adt.into()),
             Ty::FnDef(callable, ..) => Some(callable.into()),
             Ty::AssociatedType(type_alias, ..) => Some(type_alias.into()),
             Ty::ForeignType(type_alias, ..) => Some(type_alias.into()),
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 1b5843d48..5fa83567b 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -24,7 +24,6 @@ use hir_expand::name::Name;
 use la_arena::ArenaMap;
 use smallvec::SmallVec;
 use stdx::impl_from;
-use test_utils::mark;
 
 use crate::{
     db::HirDatabase,
@@ -760,7 +759,7 @@ fn assoc_type_bindings_from_type_bound<'a>(
 
 impl ReturnTypeImplTrait {
     fn from_hir(ctx: &TyLoweringContext, bounds: &[TypeBound]) -> Self {
-        mark::hit!(lower_rpit);
+        cov_mark::hit!(lower_rpit);
         let self_ty = Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0));
         let predicates = ctx.with_shifted_in(DebruijnIndex::ONE, |ctx| {
             bounds
@@ -935,7 +934,7 @@ impl TraitEnvironment {
                 // add `Self: Trait<T1, T2, ...>` to the environment in trait
                 // function default implementations (and hypothetical code
                 // inside consts or type aliases)
-                test_utils::mark::hit!(trait_self_implements_self);
+                cov_mark::hit!(trait_self_implements_self);
                 let substs = Substs::type_params(db, trait_id);
                 let trait_ref = TraitRef { trait_: trait_id, substs };
                 let pred = GenericPredicate::Implemented(trait_ref);
@@ -1100,7 +1099,7 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -
 fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
     let generics = generics(db.upcast(), adt.into());
     let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
-    Binders::new(substs.len(), Ty::Adt(adt, substs))
+    Binders::new(substs.len(), Ty::adt_ty(adt, substs))
 }
 
 fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> {
@@ -1131,8 +1130,8 @@ impl CallableDefId {
         let db = db.upcast();
         match self {
             CallableDefId::FunctionId(f) => f.lookup(db).module(db),
-            CallableDefId::StructId(s) => s.lookup(db).container.module(db),
-            CallableDefId::EnumVariantId(e) => e.parent.lookup(db).container.module(db),
+            CallableDefId::StructId(s) => s.lookup(db).container,
+            CallableDefId::EnumVariantId(e) => e.parent.lookup(db).container,
         }
         .krate()
     }
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index f301a8477..ccc12c075 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -8,8 +8,8 @@ use arrayvec::ArrayVec;
 use base_db::CrateId;
 use chalk_ir::Mutability;
 use hir_def::{
-    lang_item::LangItemTarget, AdtId, AssocContainerId, AssocItemId, FunctionId, GenericDefId,
-    HasModule, ImplId, Lookup, ModuleId, TraitId, TypeAliasId,
+    lang_item::LangItemTarget, AssocContainerId, AssocItemId, FunctionId, GenericDefId, HasModule,
+    ImplId, Lookup, ModuleId, TraitId, TypeAliasId,
 };
 use hir_expand::name::Name;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -19,8 +19,8 @@ use crate::{
     db::HirDatabase,
     primitive::{self, FloatTy, IntTy, UintTy},
     utils::all_super_traits,
-    Canonical, DebruijnIndex, FnPointer, FnSig, InEnvironment, Scalar, Substs, TraitEnvironment,
-    TraitRef, Ty, TypeWalk,
+    AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, InEnvironment, Scalar, Substs,
+    TraitEnvironment, TraitRef, Ty, TypeWalk,
 };
 
 /// This is used as a key for indexing impls.
@@ -32,7 +32,7 @@ pub enum TyFingerprint {
     Never,
     RawPtr(Mutability),
     Scalar(Scalar),
-    Adt(AdtId),
+    Adt(hir_def::AdtId),
     Dyn(TraitId),
     Tuple(usize),
     ForeignType(TypeAliasId),
@@ -50,7 +50,7 @@ impl TyFingerprint {
             &Ty::Slice(..) => TyFingerprint::Slice,
             &Ty::Array(..) => TyFingerprint::Array,
             &Ty::Scalar(scalar) => TyFingerprint::Scalar(scalar),
-            &Ty::Adt(adt, _) => TyFingerprint::Adt(adt),
+            &Ty::Adt(AdtId(adt), _) => TyFingerprint::Adt(adt),
             &Ty::Tuple(cardinality, _) => TyFingerprint::Tuple(cardinality),
             &Ty::Raw(mutability, ..) => TyFingerprint::RawPtr(mutability),
             &Ty::ForeignType(alias_id, ..) => TyFingerprint::ForeignType(alias_id),
@@ -231,7 +231,7 @@ impl Ty {
         let mod_to_crate_ids = |module: ModuleId| Some(std::iter::once(module.krate()).collect());
 
         let lang_item_targets = match self {
-            Ty::Adt(def_id, _) => {
+            Ty::Adt(AdtId(def_id), _) => {
                 return mod_to_crate_ids(def_id.module(db.upcast()));
             }
             Ty::ForeignType(type_alias_id) => {
@@ -267,7 +267,7 @@ impl Ty {
                 LangItemTarget::ImplDefId(it) => Some(it),
                 _ => None,
             })
-            .map(|it| it.lookup(db.upcast()).container.module(db.upcast()).krate())
+            .map(|it| it.lookup(db.upcast()).container.krate())
             .collect();
         Some(res)
     }
@@ -588,7 +588,7 @@ fn iterate_inherent_methods(
                 // already happens in `is_valid_candidate` above; if not, we
                 // check it here
                 if receiver_ty.is_none() && inherent_impl_substs(db, impl_def, self_ty).is_none() {
-                    test_utils::mark::hit!(impl_self_type_match_without_receiver);
+                    cov_mark::hit!(impl_self_type_match_without_receiver);
                     continue;
                 }
                 if callback(&self_ty.value, item) {
@@ -715,7 +715,7 @@ fn transform_receiver_ty(
                 .fill_with_unknown()
                 .build()
         }
-        AssocContainerId::ContainerId(_) => unreachable!(),
+        AssocContainerId::ModuleId(_) => unreachable!(),
     };
     let sig = db.callable_item_signature(function_id.into());
     Some(sig.value.params()[0].clone().subst_bound_vars(&substs))
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index 7386a4e7b..fc770ea60 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -13,7 +13,7 @@ use std::{env, sync::Arc};
 use base_db::{fixture::WithFixture, FileRange, SourceDatabase, SourceDatabaseExt};
 use expect_test::Expect;
 use hir_def::{
-    body::{BodySourceMap, SyntheticSyntax},
+    body::{Body, BodySourceMap, SyntheticSyntax},
     child_by_source::ChildBySource,
     db::DefDatabase,
     item_scope::ItemScope,
@@ -234,13 +234,13 @@ fn visit_module(
                     let def = it.into();
                     cb(def);
                     let body = db.body(def);
-                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                    visit_body(db, &body, cb);
                 }
                 AssocItemId::ConstId(it) => {
                     let def = it.into();
                     cb(def);
                     let body = db.body(def);
-                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                    visit_body(db, &body, cb);
                 }
                 AssocItemId::TypeAliasId(_) => (),
             }
@@ -259,19 +259,19 @@ fn visit_module(
                     let def = it.into();
                     cb(def);
                     let body = db.body(def);
-                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                    visit_body(db, &body, cb);
                 }
                 ModuleDefId::ConstId(it) => {
                     let def = it.into();
                     cb(def);
                     let body = db.body(def);
-                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                    visit_body(db, &body, cb);
                 }
                 ModuleDefId::StaticId(it) => {
                     let def = it.into();
                     cb(def);
                     let body = db.body(def);
-                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                    visit_body(db, &body, cb);
                 }
                 ModuleDefId::TraitId(it) => {
                     let trait_data = db.trait_data(it);
@@ -288,6 +288,14 @@ fn visit_module(
             }
         }
     }
+
+    fn visit_body(db: &TestDB, body: &Body, cb: &mut dyn FnMut(DefWithBodyId)) {
+        for def_map in body.block_scopes.iter().filter_map(|block| db.block_def_map(*block)) {
+            for (mod_id, _) in def_map.modules() {
+                visit_module(db, &def_map, mod_id, cb);
+            }
+        }
+    }
 }
 
 fn ellipsize(mut text: String, max_len: usize) -> String {
diff --git a/crates/hir_ty/src/tests/coercion.rs b/crates/hir_ty/src/tests/coercion.rs
index 7bc6c79f3..63d9d4e0b 100644
--- a/crates/hir_ty/src/tests/coercion.rs
+++ b/crates/hir_ty/src/tests/coercion.rs
@@ -1,5 +1,4 @@
 use expect_test::expect;
-use test_utils::mark;
 
 use super::{check_infer, check_infer_with_mismatches};
 
@@ -381,7 +380,7 @@ fn infer_match_second_coerce() {
 
 #[test]
 fn coerce_merge_one_by_one1() {
-    mark::check!(coerce_merge_fail_fallback);
+    cov_mark::check!(coerce_merge_fail_fallback);
 
     check_infer(
         r"
@@ -589,7 +588,7 @@ fn coerce_fn_item_to_fn_ptr() {
 
 #[test]
 fn coerce_fn_items_in_match_arms() {
-    mark::check!(coerce_fn_reification);
+    cov_mark::check!(coerce_fn_reification);
 
     check_infer_with_mismatches(
         r"
diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index a9901d7b8..4e3f9a9b6 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -913,7 +913,7 @@ fn test() { S2.into(); }
 
 #[test]
 fn method_resolution_overloaded_method() {
-    test_utils::mark::check!(impl_self_type_match_without_receiver);
+    cov_mark::check!(impl_self_type_match_without_receiver);
     check_types(
         r#"
 struct Wrapper<T>(T);
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index 2053d8f56..5da19ba5f 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -1,5 +1,4 @@
 use expect_test::expect;
-use test_utils::mark;
 
 use super::{check_infer, check_infer_with_mismatches};
 
@@ -197,7 +196,7 @@ fn infer_pattern_match_ergonomics() {
 
 #[test]
 fn infer_pattern_match_ergonomics_ref() {
-    mark::check!(match_ergonomics_ref);
+    cov_mark::check!(match_ergonomics_ref);
     check_infer(
         r#"
         fn test() {
diff --git a/crates/hir_ty/src/tests/regression.rs b/crates/hir_ty/src/tests/regression.rs
index cffe8630b..69314e245 100644
--- a/crates/hir_ty/src/tests/regression.rs
+++ b/crates/hir_ty/src/tests/regression.rs
@@ -1,5 +1,4 @@
 use expect_test::expect;
-use test_utils::mark;
 
 use super::{check_infer, check_types};
 
@@ -87,8 +86,8 @@ fn bug_651() {
 
 #[test]
 fn recursive_vars() {
-    mark::check!(type_var_cycles_resolve_completely);
-    mark::check!(type_var_cycles_resolve_as_possible);
+    cov_mark::check!(type_var_cycles_resolve_completely);
+    cov_mark::check!(type_var_cycles_resolve_as_possible);
     check_infer(
         r#"
         fn test() {
@@ -166,7 +165,7 @@ fn infer_std_crash_1() {
 
 #[test]
 fn infer_std_crash_2() {
-    mark::check!(type_var_resolves_to_int_var);
+    cov_mark::check!(type_var_resolves_to_int_var);
     // caused "equating two type variables, ...", taken from std
     check_infer(
         r#"
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 2947857a5..f5069eba5 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -1,5 +1,4 @@
 use expect_test::expect;
-use test_utils::mark;
 
 use super::{check_infer, check_types};
 
@@ -2314,7 +2313,7 @@ fn generic_default_depending_on_other_type_arg_forward() {
 
 #[test]
 fn infer_operator_overload() {
-    mark::check!(infer_expr_inner_binary_operator_overload);
+    cov_mark::check!(infer_expr_inner_binary_operator_overload);
 
     check_infer(
         r#"
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 1298e5a88..e185b1c0a 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -1,5 +1,4 @@
 use expect_test::expect;
-use test_utils::mark;
 
 use super::{check_infer, check_infer_with_mismatches, check_types};
 
@@ -319,7 +318,7 @@ fn infer_from_bound_2() {
 
 #[test]
 fn trait_default_method_self_bound_implements_trait() {
-    mark::check!(trait_self_implements_self);
+    cov_mark::check!(trait_self_implements_self);
     check_infer(
         r#"
         trait Trait {
@@ -1189,7 +1188,7 @@ fn impl_trait() {
 
 #[test]
 fn simple_return_pos_impl_trait() {
-    mark::check!(lower_rpit);
+    cov_mark::check!(lower_rpit);
     check_infer(
         r#"
         trait Trait<T> {
@@ -3175,6 +3174,39 @@ fn f() {
 }
 
 #[test]
+fn trait_in_scope_with_inner_item() {
+    check_infer(
+        r#"
+mod m {
+    pub trait Tr {
+        fn method(&self) -> u8 { 0 }
+    }
+
+    impl Tr for () {}
+}
+
+use m::Tr;
+
+fn f() {
+    fn inner() {
+        ().method();
+      //^^^^^^^^^^^ u8
+    }
+}
+        "#,
+        expect![[r#"
+            46..50 'self': &Self
+            58..63 '{ 0 }': u8
+            60..61 '0': u8
+            115..185 '{     ...   } }': ()
+            132..183 '{     ...     }': ()
+            142..144 '()': ()
+            142..153 '().method()': u8
+        "#]],
+    );
+}
+
+#[test]
 fn inner_use_in_block() {
     check_types(
         r#"
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index e513fa8f4..565672b6b 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -315,9 +315,8 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
         let id = from_chalk(self.db, trait_id);
         self.db.trait_data(id).name.to_string()
     }
-    fn adt_name(&self, adt_id: chalk_ir::AdtId<Interner>) -> String {
-        let id = from_chalk(self.db, adt_id);
-        match id {
+    fn adt_name(&self, chalk_ir::AdtId(adt_id): AdtId) -> String {
+        match adt_id {
             hir_def::AdtId::StructId(id) => self.db.struct_data(id).name.to_string(),
             hir_def::AdtId::EnumId(id) => self.db.enum_data(id).name.to_string(),
             hir_def::AdtId::UnionId(id) => self.db.union_data(id).name.to_string(),
@@ -425,7 +424,7 @@ pub(crate) fn trait_datum_query(
     let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
     let flags = rust_ir::TraitFlags {
         auto: trait_data.auto,
-        upstream: trait_.lookup(db.upcast()).container.module(db.upcast()).krate() != krate,
+        upstream: trait_.lookup(db.upcast()).container.krate() != krate,
         non_enumerable: true,
         coinductive: false, // only relevant for Chalk testing
         // FIXME: set these flags correctly
@@ -488,8 +487,8 @@ pub(crate) fn struct_datum_query(
     struct_id: AdtId,
 ) -> Arc<StructDatum> {
     debug!("struct_datum {:?}", struct_id);
-    let adt_id = from_chalk(db, struct_id);
-    let type_ctor = Ty::Adt(adt_id, Substs::empty());
+    let type_ctor = Ty::Adt(struct_id, Substs::empty());
+    let chalk_ir::AdtId(adt_id) = struct_id;
     debug!("struct {:?} = {:?}", struct_id, type_ctor);
     let num_params = generics(db.upcast(), adt_id.into()).len();
     let upstream = adt_id.module(db.upcast()).krate() != krate;
@@ -549,7 +548,7 @@ fn impl_def_datum(
     let generic_params = generics(db.upcast(), impl_id.into());
     let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
     let trait_ = trait_ref.trait_;
-    let impl_type = if impl_id.lookup(db.upcast()).container.module(db.upcast()).krate() == krate {
+    let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
         rust_ir::ImplType::Local
     } else {
         rust_ir::ImplType::External
@@ -684,10 +683,9 @@ pub(crate) fn fn_def_variance_query(
 pub(crate) fn adt_variance_query(
     db: &dyn HirDatabase,
     _krate: CrateId,
-    adt_id: AdtId,
+    chalk_ir::AdtId(adt_id): AdtId,
 ) -> Variances {
-    let adt: crate::AdtId = from_chalk(db, adt_id);
-    let generic_params = generics(db.upcast(), adt.into());
+    let generic_params = generics(db.upcast(), adt_id.into());
     Variances::from_iter(
         &Interner,
         std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()),
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index db1760e6c..3a08b67e9 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -86,7 +86,7 @@ impl ToChalk for Ty {
 
             Ty::Adt(adt_id, substs) => {
                 let substitution = substs.to_chalk(db);
-                chalk_ir::TyKind::Adt(chalk_ir::AdtId(adt_id), substitution).intern(&Interner)
+                chalk_ir::TyKind::Adt(adt_id, substitution).intern(&Interner)
             }
             Ty::Alias(AliasTy::Projection(proj_ty)) => {
                 let associated_ty_id = TypeAliasAsAssocType(proj_ty.associated_ty).to_chalk(db);
@@ -183,7 +183,7 @@ impl ToChalk for Ty {
                 Ty::Dyn(predicates)
             }
 
-            chalk_ir::TyKind::Adt(struct_id, subst) => Ty::Adt(struct_id.0, from_chalk(db, subst)),
+            chalk_ir::TyKind::Adt(adt_id, subst) => Ty::Adt(adt_id, from_chalk(db, subst)),
             chalk_ir::TyKind::AssociatedType(type_id, subst) => Ty::AssociatedType(
                 from_chalk::<TypeAliasAsAssocType, _>(db, type_id).0,
                 from_chalk(db, subst),
@@ -325,18 +325,6 @@ impl ToChalk for hir_def::ImplId {
     }
 }
 
-impl ToChalk for hir_def::AdtId {
-    type Chalk = AdtId;
-
-    fn to_chalk(self, _db: &dyn HirDatabase) -> Self::Chalk {
-        chalk_ir::AdtId(self.into())
-    }
-
-    fn from_chalk(_db: &dyn HirDatabase, id: AdtId) -> Self {
-        id.0
-    }
-}
-
 impl ToChalk for CallableDefId {
     type Chalk = FnDefId;
 
diff --git a/crates/hir_ty/src/utils.rs b/crates/hir_ty/src/utils.rs
index 65b79df0d..7351e4e54 100644
--- a/crates/hir_ty/src/utils.rs
+++ b/crates/hir_ty/src/utils.rs
@@ -259,6 +259,6 @@ fn parent_generic_def(db: &dyn DefDatabase, def: GenericDefId) -> Option<Generic
     match container {
         AssocContainerId::ImplId(it) => Some(it.into()),
         AssocContainerId::TraitId(it) => Some(it.into()),
-        AssocContainerId::ContainerId(_) => None,
+        AssocContainerId::ModuleId(_) => None,
     }
 }