63 files changed, 923 insertions, 508 deletions
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index d0def2181..e9e8dfc2e 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -410,7 +410,7 @@ impl CrateId {
 impl CrateData {
    fn add_dep(&mut self, name: CrateName, crate_id: CrateId) {
-        self.dependencies.push(Dependency { name, crate_id })
+        self.dependencies.push(Dependency { crate_id, name })
    }
 }
diff --git a/crates/cfg/src/dnf.rs b/crates/cfg/src/dnf.rs
index 30f4bcdf7..75ded9aa1 100644
--- a/crates/cfg/src/dnf.rs
+++ b/crates/cfg/src/dnf.rs
@@ -255,9 +255,9 @@ impl Builder {
 fn make_dnf(expr: CfgExpr) -> CfgExpr {
    match expr {
        CfgExpr::Invalid | CfgExpr::Atom(_) | CfgExpr::Not(_) => expr,
-        CfgExpr::Any(e) => CfgExpr::Any(e.into_iter().map(|expr| make_dnf(expr)).collect()),
+        CfgExpr::Any(e) => CfgExpr::Any(e.into_iter().map(make_dnf).collect()),
        CfgExpr::All(e) => {
-            let e = e.into_iter().map(|expr| make_nnf(expr)).collect::<Vec<_>>();
+            let e = e.into_iter().map(make_nnf).collect::<Vec<_>>();
            CfgExpr::Any(distribute_conj(&e))
        }
@@ -300,8 +300,8 @@ fn distribute_conj(conj: &[CfgExpr]) -> Vec<CfgExpr> {
 fn make_nnf(expr: CfgExpr) -> CfgExpr {
    match expr {
        CfgExpr::Invalid | CfgExpr::Atom(_) => expr,
-        CfgExpr::Any(expr) => CfgExpr::Any(expr.into_iter().map(|expr| make_nnf(expr)).collect()),
+        CfgExpr::Any(expr) => CfgExpr::Any(expr.into_iter().map(make_nnf).collect()),
-        CfgExpr::All(expr) => CfgExpr::All(expr.into_iter().map(|expr| make_nnf(expr)).collect()),
+        CfgExpr::All(expr) => CfgExpr::All(expr.into_iter().map(make_nnf).collect()),
        CfgExpr::Not(operand) => match *operand {
            CfgExpr::Invalid | CfgExpr::Atom(_) => CfgExpr::Not(operand.clone()), // Original negated expr
            CfgExpr::Not(expr) => {
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs
index 9f6d7be48..97a78ca25 100644
--- a/crates/hir/src/display.rs
+++ b/crates/hir/src/display.rs
@@ -217,7 +217,7 @@ impl HirDisplay for Variant {
 impl HirDisplay for Type {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        self.ty.value.hir_fmt(f)
+        self.ty.hir_fmt(f)
    }
 }
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index e34be7e42..30b96d7e2 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -56,9 +56,9 @@ use hir_ty::{
    primitive::UintTy,
    to_assoc_type_id,
    traits::{FnTrait, Solution, SolutionVariables},
-    AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, Cast, DebruijnIndex,
+    AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, CanonicalVarKinds, Cast,
-    InEnvironment, Interner, ProjectionTy, Scalar, Substitution, Ty, TyDefId, TyKind,
+    DebruijnIndex, InEnvironment, Interner, ProjectionTy, QuantifiedWhereClause, Scalar,
-    TyVariableKind, WhereClause,
+    Substitution, TraitEnvironment, Ty, TyDefId, TyKind, TyVariableKind, WhereClause,
 };
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
@@ -213,7 +213,7 @@ impl Crate {
                Some(TokenTree::Leaf(Leaf::Literal(Literal{ref text, ..}))) => Some(text),
                _ => None
            }
-        }).flat_map(|t| t).next();
+        }).flatten().next();
        doc_url.map(|s| s.trim_matches('"').trim_end_matches('/').to_owned() + "/")
    }
@@ -851,13 +851,7 @@ impl Function {
            .iter()
            .enumerate()
            .map(|(idx, type_ref)| {
-                let ty = Type {
+                let ty = Type { krate, env: environment.clone(), ty: ctx.lower_ty(type_ref) };
-                    krate,
-                    ty: InEnvironment {
-                        value: ctx.lower_ty(type_ref),
-                        environment: environment.clone(),
-                    },
-                };
                Param { func: self, ty, idx }
            })
            .collect()
@@ -1460,7 +1454,7 @@ impl TypeParam {
    pub fn trait_bounds(self, db: &dyn HirDatabase) -> Vec<Trait> {
        db.generic_predicates_for_param(self.id)
            .into_iter()
-            .filter_map(|pred| match &pred.value {
+            .filter_map(|pred| match &pred.skip_binders().skip_binders() {
                hir_ty::WhereClause::Implemented(trait_ref) => {
                    Some(Trait::from(trait_ref.hir_trait_id()))
                }
@@ -1540,8 +1534,8 @@ impl Impl {
        inherent.all_impls().chain(trait_.all_impls()).map(Self::from).collect()
    }
-    pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty }: Type) -> Vec<Impl> {
+    pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty, .. }: Type) -> Vec<Impl> {
-        let def_crates = match ty.value.def_crates(db, krate) {
+        let def_crates = match ty.def_crates(db, krate) {
            Some(def_crates) => def_crates,
            None => return Vec::new(),
        };
@@ -1549,14 +1543,14 @@ impl Impl {
        let filter = |impl_def: &Impl| {
            let target_ty = impl_def.target_ty(db);
            let rref = target_ty.remove_ref();
-            ty.value.equals_ctor(rref.as_ref().map_or(&target_ty.ty.value, |it| &it.ty.value))
+            ty.equals_ctor(rref.as_ref().map_or(&target_ty.ty, |it| &it.ty))
        };
        let mut all = Vec::new();
        def_crates.iter().for_each(|&id| {
            all.extend(db.inherent_impls_in_crate(id).all_impls().map(Self::from).filter(filter))
        });
-        let fp = TyFingerprint::for_impl(&ty.value);
+        let fp = TyFingerprint::for_impl(&ty);
        for id in def_crates
            .iter()
            .flat_map(|&id| Crate { id }.transitive_reverse_dependencies(db))
@@ -1643,7 +1637,8 @@ impl Impl {
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Type {
    krate: CrateId,
-    ty: InEnvironment<Ty>,
+    env: Arc<TraitEnvironment>,
+    ty: Ty,
 }
 impl Type {
@@ -1663,14 +1658,14 @@ impl Type {
    ) -> Type {
        let environment =
            resolver.generic_def().map_or_else(Default::default, |d| db.trait_environment(d));
-        Type { krate, ty: InEnvironment { value: ty, environment } }
+        Type { krate, env: environment, ty }
    }
    fn new(db: &dyn HirDatabase, krate: CrateId, lexical_env: impl HasResolver, ty: Ty) -> Type {
        let resolver = lexical_env.resolver(db.upcast());
        let environment =
            resolver.generic_def().map_or_else(Default::default, |d| db.trait_environment(d));
-        Type { krate, ty: InEnvironment { value: ty, environment } }
+        Type { krate, env: environment, ty }
    }
    fn from_def(
@@ -1684,29 +1679,29 @@ impl Type {
    }
    pub fn is_unit(&self) -> bool {
-        matches!(self.ty.value.interned(&Interner), TyKind::Tuple(0, ..))
+        matches!(self.ty.interned(&Interner), TyKind::Tuple(0, ..))
    }
    pub fn is_bool(&self) -> bool {
-        matches!(self.ty.value.interned(&Interner), TyKind::Scalar(Scalar::Bool))
+        matches!(self.ty.interned(&Interner), TyKind::Scalar(Scalar::Bool))
    }
    pub fn is_mutable_reference(&self) -> bool {
-        matches!(self.ty.value.interned(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..))
+        matches!(self.ty.interned(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..))
    }
    pub fn is_usize(&self) -> bool {
-        matches!(self.ty.value.interned(&Interner), TyKind::Scalar(Scalar::Uint(UintTy::Usize)))
+        matches!(self.ty.interned(&Interner), TyKind::Scalar(Scalar::Uint(UintTy::Usize)))
    }
    pub fn remove_ref(&self) -> Option<Type> {
-        match &self.ty.value.interned(&Interner) {
+        match &self.ty.interned(&Interner) {
            TyKind::Ref(.., ty) => Some(self.derived(ty.clone())),
            _ => None,
        }
    }
    pub fn is_unknown(&self) -> bool {
-        self.ty.value.is_unknown()
+        self.ty.is_unknown()
    }
    /// Checks that particular type `ty` implements `std::future::Future`.
@@ -1723,11 +1718,12 @@ impl Type {
            None => return false,
        };
-        let canonical_ty = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        let canonical_ty =
+            Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(&Interner) };
        method_resolution::implements_trait(
            &canonical_ty,
            db,
-            self.ty.environment.clone(),
+            self.env.clone(),
            krate,
            std_future_trait,
        )
@@ -1745,11 +1741,12 @@ impl Type {
            None => return false,
        };
-        let canonical_ty = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        let canonical_ty =
+            Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(&Interner) };
        method_resolution::implements_trait_unique(
            &canonical_ty,
            db,
-            self.ty.environment.clone(),
+            self.env.clone(),
            krate,
            fnonce_trait,
        )
@@ -1759,17 +1756,14 @@ impl Type {
        let trait_ref = hir_ty::TraitRef {
            trait_id: hir_ty::to_chalk_trait_id(trait_.id),
            substitution: Substitution::build_for_def(db, trait_.id)
-                .push(self.ty.value.clone())
+                .push(self.ty.clone())
-                .fill(args.iter().map(|t| t.ty.value.clone()))
+                .fill(args.iter().map(|t| t.ty.clone()))
                .build(),
        };
        let goal = Canonical {
-            value: hir_ty::InEnvironment::new(
+            value: hir_ty::InEnvironment::new(self.env.env.clone(), trait_ref.cast(&Interner)),
-                self.ty.environment.clone(),
+            binders: CanonicalVarKinds::empty(&Interner),
-                trait_ref.cast(&Interner),
-            ),
-            kinds: Arc::new([]),
        };
        db.trait_solve(self.krate, goal).is_some()
@@ -1783,12 +1777,12 @@ impl Type {
        alias: TypeAlias,
    ) -> Option<Type> {
        let subst = Substitution::build_for_def(db, trait_.id)
-            .push(self.ty.value.clone())
+            .push(self.ty.clone())
-            .fill(args.iter().map(|t| t.ty.value.clone()))
+            .fill(args.iter().map(|t| t.ty.clone()))
            .build();
-        let goal = Canonical {
+        let goal = Canonical::new(
-            value: InEnvironment::new(
+            InEnvironment::new(
-                self.ty.environment.clone(),
+                self.env.env.clone(),
                AliasEq {
                    alias: AliasTy::Projection(ProjectionTy {
                        associated_ty_id: to_assoc_type_id(alias.id),
@@ -1799,8 +1793,8 @@ impl Type {
                }
                .cast(&Interner),
            ),
-            kinds: Arc::new([TyVariableKind::General]),
+            [TyVariableKind::General].iter().copied(),
-        };
+        );
        match db.trait_solve(self.krate, goal)? {
            Solution::Unique(SolutionVariables(subst)) => {
@@ -1820,22 +1814,22 @@ impl Type {
    }
    pub fn as_callable(&self, db: &dyn HirDatabase) -> Option<Callable> {
-        let def = self.ty.value.callable_def(db);
+        let def = self.ty.callable_def(db);
-        let sig = self.ty.value.callable_sig(db)?;
+        let sig = self.ty.callable_sig(db)?;
        Some(Callable { ty: self.clone(), sig, def, is_bound_method: false })
    }
    pub fn is_closure(&self) -> bool {
-        matches!(&self.ty.value.interned(&Interner), TyKind::Closure { .. })
+        matches!(&self.ty.interned(&Interner), TyKind::Closure { .. })
    }
    pub fn is_fn(&self) -> bool {
-        matches!(&self.ty.value.interned(&Interner), TyKind::FnDef(..) | TyKind::Function { .. })
+        matches!(&self.ty.interned(&Interner), TyKind::FnDef(..) | TyKind::Function { .. })
    }
    pub fn is_packed(&self, db: &dyn HirDatabase) -> bool {
-        let adt_id = match self.ty.value.interned(&Interner) {
+        let adt_id = match self.ty.interned(&Interner) {
            &TyKind::Adt(hir_ty::AdtId(adt_id), ..) => adt_id,
            _ => return false,
        };
@@ -1848,11 +1842,11 @@ impl Type {
    }
    pub fn is_raw_ptr(&self) -> bool {
-        matches!(&self.ty.value.interned(&Interner), TyKind::Raw(..))
+        matches!(&self.ty.interned(&Interner), TyKind::Raw(..))
    }
    pub fn contains_unknown(&self) -> bool {
-        return go(&self.ty.value);
+        return go(&self.ty);
        fn go(ty: &Ty) -> bool {
            match ty.interned(&Interner) {
@@ -1884,7 +1878,7 @@ impl Type {
    }
    pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> {
-        let (variant_id, substs) = match self.ty.value.interned(&Interner) {
+        let (variant_id, substs) = match self.ty.interned(&Interner) {
            &TyKind::Adt(hir_ty::AdtId(AdtId::StructId(s)), ref substs) => (s.into(), substs),
            &TyKind::Adt(hir_ty::AdtId(AdtId::UnionId(u)), ref substs) => (u.into(), substs),
            _ => return Vec::new(),
@@ -1901,7 +1895,7 @@ impl Type {
    }
    pub fn tuple_fields(&self, _db: &dyn HirDatabase) -> Vec<Type> {
-        if let TyKind::Tuple(_, substs) = &self.ty.value.interned(&Interner) {
+        if let TyKind::Tuple(_, substs) = &self.ty.interned(&Interner) {
            substs.iter().map(|ty| self.derived(ty.clone())).collect()
        } else {
            Vec::new()
@@ -1911,9 +1905,10 @@ impl Type {
    pub fn autoderef<'a>(&'a self, db: &'a dyn HirDatabase) -> impl Iterator<Item = Type> + 'a {
        // There should be no inference vars in types passed here
        // FIXME check that?
-        let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        let canonical =
-        let environment = self.ty.environment.clone();
+            Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(&Interner) };
-        let ty = InEnvironment { value: canonical, environment };
+        let environment = self.env.env.clone();
+        let ty = InEnvironment { goal: canonical, environment };
        autoderef(db, Some(self.krate), ty)
            .map(|canonical| canonical.value)
            .map(move |ty| self.derived(ty))
@@ -1927,10 +1922,10 @@ impl Type {
        krate: Crate,
        mut callback: impl FnMut(AssocItem) -> Option<T>,
    ) -> Option<T> {
-        for krate in self.ty.value.def_crates(db, krate.id)? {
+        for krate in self.ty.def_crates(db, krate.id)? {
            let impls = db.inherent_impls_in_crate(krate);
-            for impl_def in impls.for_self_ty(&self.ty.value) {
+            for impl_def in impls.for_self_ty(&self.ty) {
                for &item in db.impl_data(*impl_def).items.iter() {
                    if let Some(result) = callback(item.into()) {
                        return Some(result);
@@ -1943,7 +1938,6 @@ impl Type {
    pub fn type_parameters(&self) -> impl Iterator<Item = Type> + '_ {
        self.ty
-            .value
            .strip_references()
            .substs()
            .into_iter()
@@ -1962,9 +1956,10 @@ impl Type {
        // There should be no inference vars in types passed here
        // FIXME check that?
        // FIXME replace Unknown by bound vars here
-        let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        let canonical =
+            Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(&Interner) };
-        let env = self.ty.environment.clone();
+        let env = self.env.clone();
        let krate = krate.id;
        method_resolution::iterate_method_candidates(
@@ -1993,9 +1988,10 @@ impl Type {
        // There should be no inference vars in types passed here
        // FIXME check that?
        // FIXME replace Unknown by bound vars here
-        let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        let canonical =
+            Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(&Interner) };
-        let env = self.ty.environment.clone();
+        let env = self.env.clone();
        let krate = krate.id;
        method_resolution::iterate_method_candidates(
@@ -2011,18 +2007,18 @@ impl Type {
    }
    pub fn as_adt(&self) -> Option<Adt> {
-        let (adt, _subst) = self.ty.value.as_adt()?;
+        let (adt, _subst) = self.ty.as_adt()?;
        Some(adt.into())
    }
    pub fn as_dyn_trait(&self) -> Option<Trait> {
-        self.ty.value.dyn_trait().map(Into::into)
+        self.ty.dyn_trait().map(Into::into)
    }
    pub fn as_impl_traits(&self, db: &dyn HirDatabase) -> Option<Vec<Trait>> {
-        self.ty.value.impl_trait_bounds(db).map(|it| {
+        self.ty.impl_trait_bounds(db).map(|it| {
            it.into_iter()
-                .filter_map(|pred| match pred {
+                .filter_map(|pred| match pred.skip_binders() {
                    hir_ty::WhereClause::Implemented(trait_ref) => {
                        Some(Trait::from(trait_ref.hir_trait_id()))
                    }
@@ -2033,14 +2029,11 @@ impl Type {
    }
    pub fn as_associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<Trait> {
-        self.ty.value.associated_type_parent_trait(db).map(Into::into)
+        self.ty.associated_type_parent_trait(db).map(Into::into)
    }
    fn derived(&self, ty: Ty) -> Type {
-        Type {
+        Type { krate: self.krate, env: self.env.clone(), ty }
-            krate: self.krate,
-            ty: InEnvironment { value: ty, environment: self.ty.environment.clone() },
-        }
    }
    pub fn walk(&self, db: &dyn HirDatabase, mut cb: impl FnMut(Type)) {
@@ -2061,14 +2054,17 @@ impl Type {
        fn walk_bounds(
            db: &dyn HirDatabase,
            type_: &Type,
-            bounds: &[WhereClause],
+            bounds: &[QuantifiedWhereClause],
            cb: &mut impl FnMut(Type),
        ) {
            for pred in bounds {
-                match pred {
+                match pred.skip_binders() {
                    WhereClause::Implemented(trait_ref) => {
                        cb(type_.clone());
-                        walk_substs(db, type_, &trait_ref.substitution, cb);
+                        // skip the self type. it's likely the type we just got the bounds from
+                        for ty in trait_ref.substitution.iter().skip(1) {
+                            walk_type(db, &type_.derived(ty.clone()), cb);
+                        }
                    }
                    _ => (),
                }
@@ -2076,7 +2072,7 @@ impl Type {
        }
        fn walk_type(db: &dyn HirDatabase, type_: &Type, cb: &mut impl FnMut(Type)) {
-            let ty = type_.ty.value.strip_references();
+            let ty = type_.ty.strip_references();
            match ty.interned(&Interner) {
                TyKind::Adt(..) => {
                    cb(type_.derived(ty.clone()));
@@ -2104,7 +2100,12 @@ impl Type {
                    }
                }
                TyKind::Dyn(bounds) => {
-                    walk_bounds(db, &type_.derived(ty.clone()), bounds.as_ref(), cb);
+                    walk_bounds(
+                        db,
+                        &type_.derived(ty.clone()),
+                        bounds.bounds.skip_binders().interned(),
+                        cb,
+                    );
                }
                TyKind::Ref(_, ty) | TyKind::Raw(_, ty) | TyKind::Array(ty) | TyKind::Slice(ty) => {
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 2c10f46d8..52a2bce9b 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -638,7 +638,7 @@ fn collect_attrs(
    owner: &dyn ast::AttrsOwner,
 ) -> impl Iterator<Item = Either<ast::Attr, ast::Comment>> {
    let (inner_attrs, inner_docs) = inner_attributes(owner.syntax())
-        .map_or((None, None), |(attrs, docs)| ((Some(attrs), Some(docs))));
+        .map_or((None, None), |(attrs, docs)| (Some(attrs), Some(docs)));
    let outer_attrs = owner.attrs().filter(|attr| attr.excl_token().is_none());
    let attrs = outer_attrs
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 46a3c60cd..28b73c3a1 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -1467,12 +1467,13 @@ impl ModCollector<'_, '_> {
            },
        ) {
            Ok(Ok(macro_call_id)) => {
-                self.def_collector.unexpanded_macros.push(MacroDirective {
+                // Legacy macros need to be expanded immediately, so that any macros they produce
-                    module_id: self.module_id,
+                // are in scope.
-                    ast_id,
+                self.def_collector.collect_macro_expansion(
-                    legacy: Some(macro_call_id),
+                    self.module_id,
-                    depth: self.macro_depth + 1,
+                    macro_call_id,
-                });
+                    self.macro_depth + 1,
+                );
                return;
            }
diff --git a/crates/hir_def/src/nameres/mod_resolution.rs b/crates/hir_def/src/nameres/mod_resolution.rs
index d5de9899c..d9cec0e27 100644
--- a/crates/hir_def/src/nameres/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/mod_resolution.rs
@@ -62,7 +62,7 @@ impl ModDir {
        name: &Name,
        attr_path: Option<&SmolStr>,
    ) -> Result<(FileId, bool, ModDir), String> {
-        let file_id = file_id.original_file(db.upcast());
+        let orig_file_id = file_id.original_file(db.upcast());
        let mut candidate_files = Vec::new();
        match attr_path {
@@ -70,13 +70,18 @@ impl ModDir {
                candidate_files.push(self.dir_path.join_attr(attr_path, self.root_non_dir_owner))
            }
            None => {
-                candidate_files.push(format!("{}{}.rs", self.dir_path.0, name));
+                if file_id.is_include_macro(db.upcast()) {
-                candidate_files.push(format!("{}{}/mod.rs", self.dir_path.0, name));
+                    candidate_files.push(format!("{}.rs", name));
+                    candidate_files.push(format!("{}/mod.rs", name));
+                } else {
+                    candidate_files.push(format!("{}{}.rs", self.dir_path.0, name));
+                    candidate_files.push(format!("{}{}/mod.rs", self.dir_path.0, name));
+                }
            }
        };
        for candidate in candidate_files.iter() {
-            let path = AnchoredPath { anchor: file_id, path: candidate.as_str() };
+            let path = AnchoredPath { anchor: orig_file_id, path: candidate.as_str() };
            if let Some(file_id) = db.resolve_path(path) {
                let is_mod_rs = candidate.ends_with("/mod.rs");
diff --git a/crates/hir_def/src/nameres/tests/macros.rs b/crates/hir_def/src/nameres/tests/macros.rs
index d59d3c0db..6d3cb8d7a 100644
--- a/crates/hir_def/src/nameres/tests/macros.rs
+++ b/crates/hir_def/src/nameres/tests/macros.rs
@@ -713,6 +713,27 @@ b! { static = #[] ();}
 }
 #[test]
+fn macros_defining_macros() {
+    check(
+        r#"
+macro_rules! item {
+    ($item:item) => { $item }
+}
+item! {
+    macro_rules! indirect_macro { () => { struct S {} } }
+}
+indirect_macro!();
+    "#,
+        expect![[r#"
+            crate
+            S: t
+        "#]],
+    );
+}
+#[test]
 fn resolves_proc_macros() {
    check(
        r"
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 4a2d1c087..04ea9c5d7 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -472,7 +472,7 @@ impl Scope {
            }
            Scope::ExprScope(scope) => {
                if let Some((label, name)) = scope.expr_scopes.label(scope.scope_id) {
-                    f(name.clone(), ScopeDef::Label(label))
+                    f(name, ScopeDef::Label(label))
                }
                scope.expr_scopes.entries(scope.scope_id).iter().for_each(|e| {
                    f(e.name().clone(), ScopeDef::Local(e.pat()));
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 8529b43b6..4d52904b9 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -43,7 +43,7 @@ macro_rules! register_builtin {
                db: &dyn AstDatabase,
                arg_id: EagerMacroId,
                tt: &tt::Subtree,
-            ) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+            ) -> ExpandResult<Option<ExpandedEager>> {
                let expander = match *self {
                    $( EagerExpander::$e_kind => $e_expand, )*
                };
@@ -61,6 +61,20 @@ macro_rules! register_builtin {
    };
 }
+#[derive(Debug)]
+pub struct ExpandedEager {
+    pub(crate) subtree: tt::Subtree,
+    pub(crate) fragment: FragmentKind,
+    /// The included file ID of the include macro.
+    pub(crate) included_file: Option<FileId>,
+}
+impl ExpandedEager {
+    fn new(subtree: tt::Subtree, fragment: FragmentKind) -> Self {
+        ExpandedEager { subtree, fragment, included_file: None }
+    }
+}
 pub fn find_builtin_macro(
    ident: &name::Name,
    krate: CrateId,
@@ -280,7 +294,7 @@ fn compile_error_expand(
    _db: &dyn AstDatabase,
    _id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let err = match &*tt.token_trees {
        [tt::TokenTree::Leaf(tt::Leaf::Literal(it))] => {
            let text = it.text.as_str();
@@ -294,14 +308,14 @@ fn compile_error_expand(
        _ => mbe::ExpandError::BindingError("`compile_error!` argument must be a string".into()),
    };
-    ExpandResult { value: Some((quote! {}, FragmentKind::Items)), err: Some(err) }
+    ExpandResult { value: Some(ExpandedEager::new(quote! {}, FragmentKind::Items)), err: Some(err) }
 }
 fn concat_expand(
    _db: &dyn AstDatabase,
    _arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let mut err = None;
    let mut text = String::new();
    for (i, t) in tt.token_trees.iter().enumerate() {
@@ -325,7 +339,7 @@ fn concat_expand(
            }
        }
    }
-    ExpandResult { value: Some((quote!(#text), FragmentKind::Expr)), err }
+    ExpandResult { value: Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)), err }
 }
 fn relative_file(
@@ -361,21 +375,27 @@ fn include_expand(
    db: &dyn AstDatabase,
    arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let res = (|| {
        let path = parse_string(tt)?;
        let file_id = relative_file(db, arg_id.into(), &path, false)?;
-        Ok(parse_to_token_tree(&db.file_text(file_id))
+        let subtree = parse_to_token_tree(&db.file_text(file_id))
            .ok_or_else(|| mbe::ExpandError::ConversionError)?
-            .0)
+            .0;
+        Ok((subtree, file_id))
    })();
    match res {
-        Ok(res) => {
+        Ok((subtree, file_id)) => {
            // FIXME:
            // Handle include as expression
-            ExpandResult::ok(Some((res, FragmentKind::Items)))
+            ExpandResult::ok(Some(ExpandedEager {
+                subtree,
+                fragment: FragmentKind::Items,
+                included_file: Some(file_id),
+            }))
        }
        Err(e) => ExpandResult::only_err(e),
    }
@@ -385,7 +405,7 @@ fn include_bytes_expand(
    _db: &dyn AstDatabase,
    _arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    if let Err(e) = parse_string(tt) {
        return ExpandResult::only_err(e);
    }
@@ -398,14 +418,14 @@ fn include_bytes_expand(
            id: tt::TokenId::unspecified(),
        }))],
    };
-    ExpandResult::ok(Some((res, FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(res, FragmentKind::Expr)))
 }
 fn include_str_expand(
    db: &dyn AstDatabase,
    arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let path = match parse_string(tt) {
        Ok(it) => it,
        Err(e) => return ExpandResult::only_err(e),
@@ -418,14 +438,14 @@ fn include_str_expand(
    let file_id = match relative_file(db, arg_id.into(), &path, true) {
        Ok(file_id) => file_id,
        Err(_) => {
-            return ExpandResult::ok(Some((quote!(""), FragmentKind::Expr)));
+            return ExpandResult::ok(Some(ExpandedEager::new(quote!(""), FragmentKind::Expr)));
        }
    };
    let text = db.file_text(file_id);
    let text = &*text;
-    ExpandResult::ok(Some((quote!(#text), FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)))
 }
 fn get_env_inner(db: &dyn AstDatabase, arg_id: EagerMacroId, key: &str) -> Option<String> {
@@ -437,7 +457,7 @@ fn env_expand(
    db: &dyn AstDatabase,
    arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let key = match parse_string(tt) {
        Ok(it) => it,
        Err(e) => return ExpandResult::only_err(e),
@@ -461,14 +481,14 @@ fn env_expand(
    });
    let expanded = quote! { #s };
-    ExpandResult { value: Some((expanded, FragmentKind::Expr)), err }
+    ExpandResult { value: Some(ExpandedEager::new(expanded, FragmentKind::Expr)), err }
 }
 fn option_env_expand(
    db: &dyn AstDatabase,
    arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let key = match parse_string(tt) {
        Ok(it) => it,
        Err(e) => return ExpandResult::only_err(e),
@@ -479,7 +499,7 @@ fn option_env_expand(
        Some(s) => quote! { std::option::Some(#s) },
    };
-    ExpandResult::ok(Some((expanded, FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(expanded, FragmentKind::Expr)))
 }
 #[cfg(test)]
@@ -553,16 +573,18 @@ mod tests {
                        subtree: Arc::new(parsed_args.clone()),
                        krate,
                        call: call_id,
+                        included_file: None,
                    }
                });
-                let (subtree, fragment) = expander.expand(&db, arg_id, &parsed_args).value.unwrap();
+                let expanded = expander.expand(&db, arg_id, &parsed_args).value.unwrap();
                let eager = EagerCallLoc {
                    def,
-                    fragment,
+                    fragment: expanded.fragment,
-                    subtree: Arc::new(subtree),
+                    subtree: Arc::new(expanded.subtree),
                    krate,
                    call: call_id,
+                    included_file: expanded.included_file,
                };
                let id: MacroCallId = db.intern_eager_expansion(eager).into();
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 2748e25cf..fc73e435b 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -173,7 +173,7 @@ fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
    };
    let loc = db.lookup_intern_macro(id);
    let arg = loc.kind.arg(db)?;
-    Some(arg.green().to_owned())
+    Some(arg.green())
 }
 fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 04f374a29..9eedc8461 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -124,6 +124,7 @@ pub fn expand_eager_macro(
            subtree: Arc::new(parsed_args.clone()),
            krate,
            call: call_id,
+            included_file: None,
        }
    });
    let arg_file_id: MacroCallId = arg_id.into();
@@ -143,9 +144,15 @@ pub fn expand_eager_macro(
    if let MacroDefKind::BuiltInEager(eager, _) = def.kind {
        let res = eager.expand(db, arg_id, &subtree);
-        let (subtree, fragment) = diagnostic_sink.expand_result_option(res)?;
+        let expanded = diagnostic_sink.expand_result_option(res)?;
-        let eager =
+        let eager = EagerCallLoc {
-            EagerCallLoc { def, fragment, subtree: Arc::new(subtree), krate, call: call_id };
+            def,
+            fragment: expanded.fragment,
+            subtree: Arc::new(expanded.subtree),
+            krate,
+            call: call_id,
+            included_file: expanded.included_file,
+        };
        Ok(db.intern_eager_expansion(eager))
    } else {
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index f49fd4fda..b8045fda9 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -84,7 +84,11 @@ impl HirFileId {
                    }
                    MacroCallId::EagerMacro(id) => {
                        let loc = db.lookup_intern_eager_expansion(id);
-                        loc.call.file_id
+                        if let Some(included_file) = loc.included_file {
+                            return included_file;
+                        } else {
+                            loc.call.file_id
+                        }
                    }
                };
                file_id.original_file(db)
@@ -188,6 +192,21 @@ impl HirFileId {
            }
        }
    }
+    /// Return whether this file is an include macro
+    pub fn is_include_macro(&self, db: &dyn db::AstDatabase) -> bool {
+        match self.0 {
+            HirFileIdRepr::MacroFile(macro_file) => match macro_file.macro_call_id {
+                MacroCallId::EagerMacro(id) => {
+                    let loc = db.lookup_intern_eager_expansion(id);
+                    return loc.included_file.is_some();
+                }
+                _ => {}
+            },
+            _ => {}
+        }
+        false
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -315,6 +334,8 @@ pub struct EagerCallLoc {
    pub(crate) subtree: Arc<tt::Subtree>,
    pub(crate) krate: CrateId,
    pub(crate) call: AstId<ast::MacroCall>,
+    // The included file ID of the include macro.
+    pub(crate) included_file: Option<FileId>,
 }
 /// ExpansionInfo mainly describes how to map text range between src and expanded macro
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 43de9edd6..0aeea48d5 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -48,9 +48,8 @@ impl Name {
    /// Resolve a name from the text of token.
    fn resolve(raw_text: &str) -> Name {
-        let raw_start = "r#";
+        if let Some(text) = raw_text.strip_prefix("r#") {
-        if raw_text.starts_with(raw_start) {
+            Name::new_text(SmolStr::new(text))
-            Name::new_text(SmolStr::new(&raw_text[raw_start.len()..]))
        } else {
            Name::new_text(raw_text.into())
        }
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index 23ab042c1..dc5fc759a 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -16,8 +16,8 @@ use crate::{
    to_assoc_type_id, to_chalk_trait_id,
    traits::{InEnvironment, Solution},
    utils::generics,
-    AliasEq, AliasTy, BoundVar, Canonical, DebruijnIndex, Interner, ProjectionTy, Substitution,
+    AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex, Interner,
-    TraitRef, Ty, TyKind,
+    ProjectionTy, Substitution, TraitRef, Ty, TyKind,
 };
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -27,9 +27,9 @@ pub fn autoderef<'a>(
    krate: Option<CrateId>,
    ty: InEnvironment<Canonical<Ty>>,
 ) -> impl Iterator<Item = Canonical<Ty>> + 'a {
-    let InEnvironment { value: ty, environment } = ty;
+    let InEnvironment { goal: ty, environment } = ty;
    successors(Some(ty), move |ty| {
-        deref(db, krate?, InEnvironment { value: ty, environment: environment.clone() })
+        deref(db, krate?, InEnvironment { goal: ty, environment: environment.clone() })
    })
    .take(AUTODEREF_RECURSION_LIMIT)
 }
@@ -39,8 +39,8 @@ pub(crate) fn deref(
    krate: CrateId,
    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
-    if let Some(derefed) = ty.value.value.builtin_deref() {
+    if let Some(derefed) = ty.goal.value.builtin_deref() {
-        Some(Canonical { value: derefed, kinds: ty.value.kinds.clone() })
+        Some(Canonical { value: derefed, binders: ty.goal.binders.clone() })
    } else {
        deref_by_trait(db, krate, ty)
    }
@@ -67,15 +67,15 @@ fn deref_by_trait(
    // FIXME make the Canonical / bound var handling nicer
    let parameters =
-        Substitution::build_for_generics(&generic_params).push(ty.value.value.clone()).build();
+        Substitution::build_for_generics(&generic_params).push(ty.goal.value.clone()).build();
    // Check that the type implements Deref at all
    let trait_ref =
        TraitRef { trait_id: to_chalk_trait_id(deref_trait), substitution: parameters.clone() };
    let implements_goal = Canonical {
-        kinds: ty.value.kinds.clone(),
+        binders: ty.goal.binders.clone(),
        value: InEnvironment {
-            value: trait_ref.cast(&Interner),
+            goal: trait_ref.cast(&Interner),
            environment: ty.environment.clone(),
        },
    };
@@ -89,18 +89,27 @@ fn deref_by_trait(
            associated_ty_id: to_assoc_type_id(target),
            substitution: parameters,
        }),
-        ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.kinds.len()))
+        ty: TyKind::BoundVar(BoundVar::new(
-            .intern(&Interner),
+            DebruijnIndex::INNERMOST,
+            ty.goal.binders.len(&Interner),
+        ))
+        .intern(&Interner),
    };
    let obligation = projection.cast(&Interner);
-    let in_env = InEnvironment { value: obligation, environment: ty.environment };
+    let in_env = InEnvironment { goal: obligation, environment: ty.environment };
-    let canonical = Canonical::new(
+    let canonical = Canonical {
-        in_env,
+        value: in_env,
-        ty.value.kinds.iter().copied().chain(Some(chalk_ir::TyVariableKind::General)),
+        binders: CanonicalVarKinds::from_iter(
-    );
+            &Interner,
+            ty.goal.binders.iter(&Interner).cloned().chain(Some(chalk_ir::WithKind::new(
+                chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
+                chalk_ir::UniverseIndex::ROOT,
+            ))),
+        ),
+    };
    let solution = db.trait_solve(krate, canonical)?;
@@ -121,21 +130,21 @@ fn deref_by_trait(
            // assumptions will be broken. We would need to properly introduce
            // new variables in that case
-            for i in 1..vars.0.kinds.len() {
+            for i in 1..vars.0.binders.len(&Interner) {
                if vars.0.value[i - 1].interned(&Interner)
                    != &TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
                {
-                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.value, solution);
+                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.goal, solution);
                    return None;
                }
            }
            Some(Canonical {
                value: vars.0.value[vars.0.value.len() - 1].clone(),
-                kinds: vars.0.kinds.clone(),
+                binders: vars.0.binders.clone(),
            })
        }
        Solution::Ambig(_) => {
-            info!("Ambiguous solution for derefing {:?}: {:?}", ty.value, solution);
+            info!("Ambiguous solution for derefing {:?}: {:?}", ty.goal, solution);
            None
        }
    }
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index 91a2e0b5b..58e4247c6 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -12,8 +12,8 @@ use la_arena::ArenaMap;
 use crate::{
    method_resolution::{InherentImpls, TraitImpls},
    traits::chalk,
-    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, PolyFnSig, ReturnTypeImplTraits,
+    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, PolyFnSig,
-    TraitRef, Ty, TyDefId, ValueTyDefId, WhereClause,
+    QuantifiedWhereClause, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId,
 };
 use hir_expand::name::Name;
@@ -57,10 +57,13 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::invoke(crate::lower::generic_predicates_for_param_query)]
    #[salsa::cycle(crate::lower::generic_predicates_for_param_recover)]
-    fn generic_predicates_for_param(&self, param_id: TypeParamId) -> Arc<[Binders<WhereClause>]>;
+    fn generic_predicates_for_param(
+        &self,
+        param_id: TypeParamId,
+    ) -> Arc<[Binders<QuantifiedWhereClause>]>;
    #[salsa::invoke(crate::lower::generic_predicates_query)]
-    fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<WhereClause>]>;
+    fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<QuantifiedWhereClause>]>;
    #[salsa::invoke(crate::lower::trait_environment_query)]
    fn trait_environment(&self, def: GenericDefId) -> Arc<crate::TraitEnvironment>;
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 981ba564d..6149067c7 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
-use std::{borrow::Cow, fmt};
+use std::fmt;
 use arrayvec::ArrayVec;
 use chalk_ir::Mutability;
@@ -20,7 +20,7 @@ use crate::{
    db::HirDatabase, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, primitive,
    to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasEq, AliasTy,
    CallableDefId, CallableSig, DomainGoal, ImplTraitId, Interner, Lifetime, OpaqueTy,
-    ProjectionTy, Scalar, Substitution, TraitRef, Ty, TyKind, WhereClause,
+    ProjectionTy, QuantifiedWhereClause, Scalar, Substitution, TraitRef, Ty, TyKind, WhereClause,
 };
 pub struct HirFormatter<'a> {
@@ -329,9 +329,9 @@ impl HirDisplay for Ty {
                // FIXME: all this just to decide whether to use parentheses...
                let datas;
-                let predicates = match t.interned(&Interner) {
+                let predicates: Vec<_> = match t.interned(&Interner) {
-                    TyKind::Dyn(predicates) if predicates.len() > 1 => {
+                    TyKind::Dyn(dyn_ty) if dyn_ty.bounds.skip_binders().interned().len() > 1 => {
-                        Cow::Borrowed(predicates.as_ref())
+                        dyn_ty.bounds.skip_binders().interned().iter().cloned().collect()
                    }
                    &TyKind::Alias(AliasTy::Opaque(OpaqueTy {
                        opaque_ty_id,
@@ -346,17 +346,21 @@ impl HirDisplay for Ty {
                                .as_ref()
                                .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
                            let bounds = data.subst(parameters);
-                            Cow::Owned(bounds.value)
+                            bounds.value
                        } else {
-                            Cow::Borrowed(&[][..])
+                            Vec::new()
                        }
                    }
-                    _ => Cow::Borrowed(&[][..]),
+                    _ => Vec::new(),
                };
-                if let [WhereClause::Implemented(trait_ref), _] = predicates.as_ref() {
+                if let Some(WhereClause::Implemented(trait_ref)) =
+                    predicates.get(0).map(|b| b.skip_binders())
+                {
                    let trait_ = trait_ref.hir_trait_id();
-                    if fn_traits(f.db.upcast(), trait_).any(|it| it == trait_) {
+                    if fn_traits(f.db.upcast(), trait_).any(|it| it == trait_)
+                        && predicates.len() <= 2
+                    {
                        return write!(f, "{}", ty_display);
                    }
                }
@@ -577,19 +581,32 @@ impl HirDisplay for Ty {
                        write!(f, "{}", param_data.name.clone().unwrap_or_else(Name::missing))?
                    }
                    TypeParamProvenance::ArgumentImplTrait => {
-                        let bounds = f.db.generic_predicates_for_param(id);
                        let substs = Substitution::type_params_for_generics(f.db, &generics);
-                        write_bounds_like_dyn_trait_with_prefix(
+                        let bounds = f
-                            "impl",
+                            .db
-                            &bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(),
+                            .generic_predicates(id.parent)
-                            f,
+                            .into_iter()
-                        )?;
+                            .map(|pred| pred.clone().subst(&substs))
+                            .filter(|wc| match &wc.skip_binders() {
+                                WhereClause::Implemented(tr) => tr.self_type_parameter() == self,
+                                WhereClause::AliasEq(AliasEq {
+                                    alias: AliasTy::Projection(proj),
+                                    ty: _,
+                                }) => proj.self_type_parameter() == self,
+                                _ => false,
+                            })
+                            .collect::<Vec<_>>();
+                        write_bounds_like_dyn_trait_with_prefix("impl", &bounds, f)?;
                    }
                }
            }
            TyKind::BoundVar(idx) => write!(f, "?{}.{}", idx.debruijn.depth(), idx.index)?,
-            TyKind::Dyn(predicates) => {
+            TyKind::Dyn(dyn_ty) => {
-                write_bounds_like_dyn_trait_with_prefix("dyn", predicates, f)?;
+                write_bounds_like_dyn_trait_with_prefix(
+                    "dyn",
+                    dyn_ty.bounds.skip_binders().interned(),
+                    f,
+                )?;
            }
            TyKind::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?,
            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
@@ -658,7 +675,7 @@ fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = Trai
 pub fn write_bounds_like_dyn_trait_with_prefix(
    prefix: &str,
-    predicates: &[WhereClause],
+    predicates: &[QuantifiedWhereClause],
    f: &mut HirFormatter,
 ) -> Result<(), HirDisplayError> {
    write!(f, "{}", prefix)?;
@@ -671,7 +688,7 @@ pub fn write_bounds_like_dyn_trait_with_prefix(
 }
 fn write_bounds_like_dyn_trait(
-    predicates: &[WhereClause],
+    predicates: &[QuantifiedWhereClause],
    f: &mut HirFormatter,
 ) -> Result<(), HirDisplayError> {
    // Note: This code is written to produce nice results (i.e.
@@ -684,7 +701,7 @@ fn write_bounds_like_dyn_trait(
    let mut angle_open = false;
    let mut is_fn_trait = false;
    for p in predicates.iter() {
-        match p {
+        match p.skip_binders() {
            WhereClause::Implemented(trait_ref) => {
                let trait_ = trait_ref.hir_trait_id();
                if !is_fn_trait {
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index b9e434c78..8f9cf7480 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -331,7 +331,7 @@ impl<'a> InferenceContext<'a> {
    fn resolve_obligations_as_possible(&mut self) {
        let obligations = mem::replace(&mut self.obligations, Vec::new());
        for obligation in obligations {
-            let in_env = InEnvironment::new(self.trait_env.clone(), obligation.clone());
+            let in_env = InEnvironment::new(self.trait_env.env.clone(), obligation.clone());
            let canonicalized = self.canonicalizer().canonicalize_obligation(in_env);
            let solution =
                self.db.trait_solve(self.resolver.krate().unwrap(), canonicalized.value.clone());
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 07eb96573..9c62932b1 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -142,7 +142,7 @@ impl<'a> InferenceContext<'a> {
            .build();
        let trait_ref =
            TraitRef { trait_id: to_chalk_trait_id(coerce_unsized_trait), substitution: substs };
-        let goal = InEnvironment::new(self.trait_env.clone(), trait_ref.cast(&Interner));
+        let goal = InEnvironment::new(self.trait_env.env.clone(), trait_ref.cast(&Interner));
        let canonicalizer = self.canonicalizer();
        let canonicalized = canonicalizer.canonicalize_obligation(goal);
@@ -170,8 +170,8 @@ impl<'a> InferenceContext<'a> {
            self.db,
            self.resolver.krate(),
            InEnvironment {
-                value: canonicalized.value.clone(),
+                goal: canonicalized.value.clone(),
-                environment: self.trait_env.clone(),
+                environment: self.trait_env.env.clone(),
            },
        ) {
            let derefed_ty = canonicalized.decanonicalize_ty(derefed_ty.value);
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 79bbc5dab..19249973c 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -11,6 +11,7 @@ use hir_def::{
    AssocContainerId, FieldId, Lookup,
 };
 use hir_expand::name::{name, Name};
+use stdx::always;
 use syntax::ast::RangeOp;
 use crate::{
@@ -89,12 +90,12 @@ impl<'a> InferenceContext<'a> {
        let substs =
            Substitution::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
-        let trait_env = Arc::clone(&self.trait_env);
+        let trait_env = self.trait_env.env.clone();
        let implements_fn_trait: DomainGoal =
            TraitRef { trait_id: to_chalk_trait_id(fn_once_trait), substitution: substs.clone() }
                .cast(&Interner);
        let goal = self.canonicalizer().canonicalize_obligation(InEnvironment {
-            value: implements_fn_trait.clone(),
+            goal: implements_fn_trait.clone(),
            environment: trait_env,
        });
        if self.db.trait_solve(krate, goal.value).is_some() {
@@ -298,8 +299,8 @@ impl<'a> InferenceContext<'a> {
                    self.db,
                    self.resolver.krate(),
                    InEnvironment {
-                        value: canonicalized.value.clone(),
+                        goal: canonicalized.value.clone(),
-                        environment: self.trait_env.clone(),
+                        environment: self.trait_env.env.clone(),
                    },
                );
                let (param_tys, ret_ty): (Vec<Ty>, Ty) = derefs
@@ -437,8 +438,8 @@ impl<'a> InferenceContext<'a> {
                    self.db,
                    self.resolver.krate(),
                    InEnvironment {
-                        value: canonicalized.value.clone(),
+                        goal: canonicalized.value.clone(),
-                        environment: self.trait_env.clone(),
+                        environment: self.trait_env.env.clone(),
                    },
                )
                .find_map(|derefed_ty| {
@@ -513,10 +514,10 @@ impl<'a> InferenceContext<'a> {
                let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
                if let Some(box_) = self.resolve_boxed_box() {
                    let mut sb =
-                        Substitution::builder(generics(self.db.upcast(), box_.into()).len());
+                        Substitution::build_for_generics(&generics(self.db.upcast(), box_.into()));
                    sb = sb.push(inner_ty);
-                    match self.db.generic_defaults(box_.into()).as_ref() {
+                    match self.db.generic_defaults(box_.into()).get(1) {
-                        [_, alloc_ty, ..] if !alloc_ty.value.is_unknown() => {
+                        Some(alloc_ty) if !alloc_ty.value.is_unknown() && sb.remaining() > 0 => {
                            sb = sb.push(alloc_ty.value.clone());
                        }
                        _ => (),
@@ -537,8 +538,8 @@ impl<'a> InferenceContext<'a> {
                                self.db,
                                krate,
                                InEnvironment {
-                                    value: &canonicalized.value,
+                                    goal: &canonicalized.value,
-                                    environment: self.trait_env.clone(),
+                                    environment: self.trait_env.env.clone(),
                                },
                            ) {
                                Some(derefed_ty) => {
@@ -936,7 +937,9 @@ impl<'a> InferenceContext<'a> {
            let def: CallableDefId = from_chalk(self.db, *fn_def);
            let generic_predicates = self.db.generic_predicates(def.into());
            for predicate in generic_predicates.iter() {
-                let predicate = predicate.clone().subst(parameters);
+                let (predicate, binders) =
+                    predicate.clone().subst(parameters).into_value_and_skipped_binders();
+                always!(binders == 0); // quantified where clauses not yet handled
                self.obligations.push(predicate.cast(&Interner));
            }
            // add obligation for trait implementation, if this is a trait method
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index befa0d69b..474363709 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -13,7 +13,9 @@ use hir_expand::name::Name;
 use super::{BindingMode, Expectation, InferenceContext};
 use crate::{
-    lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substitution, Ty, TyKind,
+    lower::lower_to_chalk_mutability,
+    utils::{generics, variant_data},
+    Interner, Substitution, Ty, TyKind,
 };
 impl<'a> InferenceContext<'a> {
@@ -38,7 +40,7 @@ impl<'a> InferenceContext<'a> {
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        let (pre, post) = match ellipsis {
            Some(idx) => subpats.split_at(idx),
-            None => (&subpats[..], &[][..]),
+            None => (subpats, &[][..]),
        };
        let post_idx_offset = field_tys.iter().count() - post.len();
@@ -233,13 +235,31 @@ impl<'a> InferenceContext<'a> {
            Pat::Lit(expr) => self.infer_expr(*expr, &Expectation::has_type(expected.clone())),
            Pat::Box { inner } => match self.resolve_boxed_box() {
                Some(box_adt) => {
-                    let inner_expected = match expected.as_adt() {
+                    let (inner_ty, alloc_ty) = match expected.as_adt() {
-                        Some((adt, substs)) if adt == box_adt => substs.as_single().clone(),
+                        Some((adt, subst)) if adt == box_adt => {
-                        _ => self.result.standard_types.unknown.clone(),
+                            (subst[0].clone(), subst.get(1).cloned())
+                        }
+                        _ => (self.result.standard_types.unknown.clone(), None),
                    };
-                    let inner_ty = self.infer_pat(*inner, &inner_expected, default_bm);
+                    let inner_ty = self.infer_pat(*inner, &inner_ty, default_bm);
-                    Ty::adt_ty(box_adt, Substitution::single(inner_ty))
+                    let mut sb = Substitution::build_for_generics(&generics(
+                        self.db.upcast(),
+                        box_adt.into(),
+                    ));
+                    sb = sb.push(inner_ty);
+                    if sb.remaining() == 1 {
+                        sb = sb.push(match alloc_ty {
+                            Some(alloc_ty) if !alloc_ty.is_unknown() => alloc_ty,
+                            _ => match self.db.generic_defaults(box_adt.into()).get(1) {
+                                Some(alloc_ty) if !alloc_ty.value.is_unknown() => {
+                                    alloc_ty.value.clone()
+                                }
+                                _ => self.table.new_type_var(),
+                            },
+                        });
+                    }
+                    Ty::adt_ty(box_adt, sb.build())
                }
                None => self.err_ty(),
            },
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 1fc03c8f4..75250a369 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -2,13 +2,13 @@
 use std::borrow::Cow;
-use chalk_ir::{FloatTy, IntTy, TyVariableKind};
+use chalk_ir::{FloatTy, IntTy, TyVariableKind, UniverseIndex, VariableKind};
 use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use super::{DomainGoal, InferenceContext};
 use crate::{
-    AliasEq, AliasTy, BoundVar, Canonical, DebruijnIndex, FnPointer, InEnvironment, InferenceVar,
+    AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex, FnPointer,
-    Interner, Scalar, Substitution, Ty, TyKind, TypeWalk, WhereClause,
+    InEnvironment, InferenceVar, Interner, Scalar, Substitution, Ty, TyKind, TypeWalk, WhereClause,
 };
 impl<'a> InferenceContext<'a> {
@@ -76,8 +76,17 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
    }
    fn into_canonicalized<T>(self, result: T) -> Canonicalized<T> {
-        let kinds = self.free_vars.iter().map(|&(_, k)| k).collect();
+        let kinds = self
-        Canonicalized { value: Canonical { value: result, kinds }, free_vars: self.free_vars }
+            .free_vars
+            .iter()
+            .map(|&(_, k)| chalk_ir::WithKind::new(VariableKind::Ty(k), UniverseIndex::ROOT));
+        Canonicalized {
+            value: Canonical {
+                value: result,
+                binders: CanonicalVarKinds::from_iter(&Interner, kinds),
+            },
+            free_vars: self.free_vars,
+        }
    }
    pub(crate) fn canonicalize_ty(mut self, ty: Ty) -> Canonicalized<Ty> {
@@ -89,15 +98,12 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
        mut self,
        obligation: InEnvironment<DomainGoal>,
    ) -> Canonicalized<InEnvironment<DomainGoal>> {
-        let result = match obligation.value {
+        let result = match obligation.goal {
            DomainGoal::Holds(wc) => {
                DomainGoal::Holds(self.do_canonicalize(wc, DebruijnIndex::INNERMOST))
            }
        };
-        self.into_canonicalized(InEnvironment {
+        self.into_canonicalized(InEnvironment { goal: result, environment: obligation.environment })
-            value: result,
-            environment: obligation.environment,
-        })
    }
 }
@@ -125,12 +131,19 @@ impl<T> Canonicalized<T> {
        // the solution may contain new variables, which we need to convert to new inference vars
        let new_vars = Substitution(
            solution
-                .kinds
+                .binders
-                .iter()
+                .iter(&Interner)
-                .map(|k| match k {
+                .map(|k| match k.kind {
-                    TyVariableKind::General => ctx.table.new_type_var(),
+                    VariableKind::Ty(TyVariableKind::General) => ctx.table.new_type_var(),
-                    TyVariableKind::Integer => ctx.table.new_integer_var(),
+                    VariableKind::Ty(TyVariableKind::Integer) => ctx.table.new_integer_var(),
-                    TyVariableKind::Float => ctx.table.new_float_var(),
+                    VariableKind::Ty(TyVariableKind::Float) => ctx.table.new_float_var(),
+                    // HACK: Chalk can sometimes return new lifetime variables. We
+                    // want to just skip them, but to not mess up the indices of
+                    // other variables, we'll just create a new type variable in
+                    // their place instead. This should not matter (we never see the
+                    // actual *uses* of the lifetime variable).
+                    VariableKind::Lifetime => ctx.table.new_type_var(),
+                    _ => panic!("const variable in solution"),
                })
                .collect(),
        );
@@ -147,8 +160,8 @@ impl<T> Canonicalized<T> {
 pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substitution> {
    let mut table = InferenceTable::new();
    let vars = Substitution(
-        tys.kinds
+        tys.binders
-            .iter()
+            .iter(&Interner)
            // we always use type vars here because we want everything to
            // fallback to Unknown in the end (kind of hacky, as below)
            .map(|_| table.new_type_var())
@@ -170,7 +183,7 @@ pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substitution> {
        }
    }
    Some(
-        Substitution::builder(tys.kinds.len())
+        Substitution::builder(tys.binders.len(&Interner))
            .fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone())))
            .build(),
    )
@@ -310,9 +323,18 @@ impl InferenceTable {
            (TyKind::Placeholder(p1), TyKind::Placeholder(p2)) if *p1 == *p2 => true,
-            (TyKind::Dyn(dyn1), TyKind::Dyn(dyn2)) if dyn1.len() == dyn2.len() => {
+            (TyKind::Dyn(dyn1), TyKind::Dyn(dyn2))
-                for (pred1, pred2) in dyn1.iter().zip(dyn2.iter()) {
+                if dyn1.bounds.skip_binders().interned().len()
-                    if !self.unify_preds(pred1, pred2, depth + 1) {
+                    == dyn2.bounds.skip_binders().interned().len() =>
+            {
+                for (pred1, pred2) in dyn1
+                    .bounds
+                    .skip_binders()
+                    .interned()
+                    .iter()
+                    .zip(dyn2.bounds.skip_binders().interned().iter())
+                {
+                    if !self.unify_preds(pred1.skip_binders(), pred2.skip_binders(), depth + 1) {
                        return false;
                    }
                }
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index c46529879..0f49dd39b 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -61,6 +61,8 @@ pub type ClosureId = chalk_ir::ClosureId<Interner>;
 pub type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
 pub type PlaceholderIndex = chalk_ir::PlaceholderIndex;
+pub type CanonicalVarKinds = chalk_ir::CanonicalVarKinds<Interner>;
 pub type ChalkTraitId = chalk_ir::TraitId<Interner>;
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -106,6 +108,10 @@ impl ProjectionTy {
        }
    }
+    pub fn self_type_parameter(&self) -> &Ty {
+        &self.substitution[0]
+    }
    fn trait_(&self, db: &dyn HirDatabase) -> TraitId {
        match from_assoc_type_id(self.associated_ty_id).lookup(db.upcast()).container {
            AssocContainerId::TraitId(it) => it,
@@ -128,6 +134,12 @@ impl TypeWalk for ProjectionTy {
    }
 }
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub struct DynTy {
+    /// The unknown self type.
+    pub bounds: Binders<QuantifiedWhereClauses>,
+}
 pub type FnSig = chalk_ir::FnSig<Interner>;
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -279,7 +291,7 @@ pub enum TyKind {
    /// represents the `Self` type inside the bounds. This is currently
    /// implicit; Chalk has the `Binders` struct to make it explicit, but it
    /// didn't seem worth the overhead yet.
-    Dyn(Arc<[WhereClause]>),
+    Dyn(DynTy),
    /// A placeholder for a type which could not be computed; this is propagated
    /// to avoid useless error messages. Doubles as a placeholder where type
@@ -486,6 +498,13 @@ impl<T> Binders<T> {
        Self { num_binders, value }
    }
+    pub fn wrap_empty(value: T) -> Self
+    where
+        T: TypeWalk,
+    {
+        Self { num_binders: 0, value: value.shift_bound_vars(DebruijnIndex::ONE) }
+    }
    pub fn as_ref(&self) -> Binders<&T> {
        Binders { num_binders: self.num_binders, value: &self.value }
    }
@@ -497,6 +516,14 @@ impl<T> Binders<T> {
    pub fn filter_map<U>(self, f: impl FnOnce(T) -> Option<U>) -> Option<Binders<U>> {
        Some(Binders { num_binders: self.num_binders, value: f(self.value)? })
    }
+    pub fn skip_binders(&self) -> &T {
+        &self.value
+    }
+    pub fn into_value_and_skipped_binders(self) -> (T, usize) {
+        (self.value, self.num_binders)
+    }
 }
 impl<T: Clone> Binders<&T> {
@@ -610,6 +637,24 @@ impl TypeWalk for WhereClause {
    }
 }
+pub type QuantifiedWhereClause = Binders<WhereClause>;
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct QuantifiedWhereClauses(Arc<[QuantifiedWhereClause]>);
+impl QuantifiedWhereClauses {
+    pub fn from_iter(
+        _interner: &Interner,
+        elements: impl IntoIterator<Item = QuantifiedWhereClause>,
+    ) -> Self {
+        QuantifiedWhereClauses(elements.into_iter().collect())
+    }
+    pub fn interned(&self) -> &Arc<[QuantifiedWhereClause]> {
+        &self.0
+    }
+}
 /// Basically a claim (currently not validated / checked) that the contained
 /// type / trait ref contains no inference variables; any inference variables it
 /// contained have been replaced by bound variables, and `kinds` tells us how
@@ -619,12 +664,18 @@ impl TypeWalk for WhereClause {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Canonical<T> {
    pub value: T,
-    pub kinds: Arc<[TyVariableKind]>,
+    pub binders: CanonicalVarKinds,
 }
 impl<T> Canonical<T> {
    pub fn new(value: T, kinds: impl IntoIterator<Item = TyVariableKind>) -> Self {
-        Self { value, kinds: kinds.into_iter().collect() }
+        let kinds = kinds.into_iter().map(|tk| {
+            chalk_ir::CanonicalVarKind::new(
+                chalk_ir::VariableKind::Ty(tk),
+                chalk_ir::UniverseIndex::ROOT,
+            )
+        });
+        Self { value, binders: chalk_ir::CanonicalVarKinds::from_iter(&Interner, kinds) }
    }
 }
@@ -806,12 +857,14 @@ impl Ty {
    }
    /// If this is a `dyn Trait` type, this returns the `Trait` part.
-    pub fn dyn_trait_ref(&self) -> Option<&TraitRef> {
+    fn dyn_trait_ref(&self) -> Option<&TraitRef> {
        match self.interned(&Interner) {
-            TyKind::Dyn(bounds) => bounds.get(0).and_then(|b| match b {
+            TyKind::Dyn(dyn_ty) => {
-                WhereClause::Implemented(trait_ref) => Some(trait_ref),
+                dyn_ty.bounds.value.interned().get(0).and_then(|b| match b.skip_binders() {
-                _ => None,
+                    WhereClause::Implemented(trait_ref) => Some(trait_ref),
-            }),
+                    _ => None,
+                })
+            }
            _ => None,
        }
    }
@@ -888,7 +941,7 @@ impl Ty {
        }
    }
-    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<WhereClause>> {
+    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<QuantifiedWhereClause>> {
        match self.interned(&Interner) {
            TyKind::OpaqueType(opaque_ty_id, ..) => {
                match db.lookup_intern_impl_trait_id((*opaque_ty_id).into()) {
@@ -901,10 +954,13 @@ impl Ty {
                            // This is only used by type walking.
                            // Parameters will be walked outside, and projection predicate is not used.
                            // So just provide the Future trait.
-                            let impl_bound = WhereClause::Implemented(TraitRef {
+                            let impl_bound = Binders::new(
-                                trait_id: to_chalk_trait_id(future_trait),
+                                0,
-                                substitution: Substitution::empty(),
+                                WhereClause::Implemented(TraitRef {
-                            });
+                                    trait_id: to_chalk_trait_id(future_trait),
+                                    substitution: Substitution::empty(),
+                                }),
+                            );
                            Some(vec![impl_bound])
                        } else {
                            None
@@ -936,10 +992,19 @@ impl Ty {
                let param_data = &generic_params.types[id.local_id];
                match param_data.provenance {
                    hir_def::generics::TypeParamProvenance::ArgumentImplTrait => {
+                        let substs = Substitution::type_params(db, id.parent);
                        let predicates = db
-                            .generic_predicates_for_param(id)
+                            .generic_predicates(id.parent)
                            .into_iter()
-                            .map(|pred| pred.value.clone())
+                            .map(|pred| pred.clone().subst(&substs))
+                            .filter(|wc| match &wc.skip_binders() {
+                                WhereClause::Implemented(tr) => tr.self_type_parameter() == self,
+                                WhereClause::AliasEq(AliasEq {
+                                    alias: AliasTy::Projection(proj),
+                                    ty: _,
+                                }) => proj.self_type_parameter() == self,
+                                _ => false,
+                            })
                            .collect_vec();
                        Some(predicates)
@@ -1081,8 +1146,8 @@ impl TypeWalk for Ty {
                    t.walk(f);
                }
            }
-            TyKind::Dyn(predicates) => {
+            TyKind::Dyn(dyn_ty) => {
-                for p in predicates.iter() {
+                for p in dyn_ty.bounds.value.interned().iter() {
                    p.walk(f);
                }
            }
@@ -1109,8 +1174,8 @@ impl TypeWalk for Ty {
            TyKind::Alias(AliasTy::Projection(p_ty)) => {
                p_ty.substitution.walk_mut_binders(f, binders);
            }
-            TyKind::Dyn(predicates) => {
+            TyKind::Dyn(dyn_ty) => {
-                for p in make_mut_slice(predicates) {
+                for p in make_mut_slice(&mut dyn_ty.bounds.value.0) {
                    p.walk_mut_binders(f, binders.shifted_in());
                }
            }
@@ -1160,7 +1225,7 @@ pub struct ReturnTypeImplTraits {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
-    pub(crate) bounds: Binders<Vec<WhereClause>>,
+    pub(crate) bounds: Binders<Vec<QuantifiedWhereClause>>,
 }
 pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index cbbb535e5..f60cec649 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -33,9 +33,10 @@ use crate::{
        all_super_trait_refs, associated_type_by_name_including_super_traits, generics,
        variant_data,
    },
-    AliasEq, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, ImplTraitId,
+    AliasEq, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, DynTy, FnPointer, FnSig,
-    OpaqueTy, PolyFnSig, ProjectionTy, ReturnTypeImplTrait, ReturnTypeImplTraits, Substitution,
+    ImplTraitId, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause, QuantifiedWhereClauses,
-    TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk, WhereClause,
+    ReturnTypeImplTrait, ReturnTypeImplTraits, Substitution, TraitEnvironment, TraitRef, Ty,
+    TyKind, TypeWalk, WhereClause,
 };
 #[derive(Debug)]
@@ -188,10 +189,14 @@ impl<'a> TyLoweringContext<'a> {
            TypeRef::DynTrait(bounds) => {
                let self_ty =
                    TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner);
-                let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {
+                let bounds = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {
-                    bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone())).collect()
+                    QuantifiedWhereClauses::from_iter(
+                        &Interner,
+                        bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone(), false)),
+                    )
                });
-                TyKind::Dyn(predicates).intern(&Interner)
+                let bounds = Binders::new(1, bounds);
+                TyKind::Dyn(DynTy { bounds }).intern(&Interner)
            }
            TypeRef::ImplTrait(bounds) => {
                match self.impl_trait_mode {
@@ -373,7 +378,16 @@ impl<'a> TyLoweringContext<'a> {
                    // FIXME report error (ambiguous associated type)
                    TyKind::Unknown.intern(&Interner)
                } else {
-                    TyKind::Dyn(Arc::new([WhereClause::Implemented(trait_ref)])).intern(&Interner)
+                    let dyn_ty = DynTy {
+                        bounds: Binders::new(
+                            1,
+                            QuantifiedWhereClauses::from_iter(
+                                &Interner,
+                                Some(Binders::wrap_empty(WhereClause::Implemented(trait_ref))),
+                            ),
+                        ),
+                    };
+                    TyKind::Dyn(dyn_ty).intern(&Interner)
                };
                return (ty, None);
            }
@@ -666,7 +680,8 @@ impl<'a> TyLoweringContext<'a> {
    pub(crate) fn lower_where_predicate(
        &'a self,
        where_predicate: &'a WherePredicate,
-    ) -> impl Iterator<Item = WhereClause> + 'a {
+        ignore_bindings: bool,
+    ) -> impl Iterator<Item = QuantifiedWhereClause> + 'a {
        match where_predicate {
            WherePredicate::ForLifetime { target, bound, .. }
            | WherePredicate::TypeBound { target, bound } => {
@@ -688,7 +703,9 @@ impl<'a> TyLoweringContext<'a> {
                        .intern(&Interner)
                    }
                };
-                self.lower_type_bound(bound, self_ty).collect::<Vec<_>>().into_iter()
+                self.lower_type_bound(bound, self_ty, ignore_bindings)
+                    .collect::<Vec<_>>()
+                    .into_iter()
            }
            WherePredicate::Lifetime { .. } => vec![].into_iter(),
        }
@@ -698,12 +715,13 @@ impl<'a> TyLoweringContext<'a> {
        &'a self,
        bound: &'a TypeBound,
        self_ty: Ty,
-    ) -> impl Iterator<Item = WhereClause> + 'a {
+        ignore_bindings: bool,
+    ) -> impl Iterator<Item = QuantifiedWhereClause> + 'a {
        let mut bindings = None;
        let trait_ref = match bound {
            TypeBound::Path(path) => {
                bindings = self.lower_trait_ref_from_path(path, Some(self_ty));
-                bindings.clone().map(WhereClause::Implemented)
+                bindings.clone().map(WhereClause::Implemented).map(|b| Binders::wrap_empty(b))
            }
            TypeBound::Lifetime(_) => None,
            TypeBound::Error => None,
@@ -711,6 +729,7 @@ impl<'a> TyLoweringContext<'a> {
        trait_ref.into_iter().chain(
            bindings
                .into_iter()
+                .filter(move |_| !ignore_bindings)
                .flat_map(move |tr| self.assoc_type_bindings_from_type_bound(bound, tr)),
        )
    }
@@ -719,7 +738,7 @@ impl<'a> TyLoweringContext<'a> {
        &'a self,
        bound: &'a TypeBound,
        trait_ref: TraitRef,
-    ) -> impl Iterator<Item = WhereClause> + 'a {
+    ) -> impl Iterator<Item = QuantifiedWhereClause> + 'a {
        let last_segment = match bound {
            TypeBound::Path(path) => path.segments().last(),
            TypeBound::Error | TypeBound::Lifetime(_) => None,
@@ -735,7 +754,7 @@ impl<'a> TyLoweringContext<'a> {
                    &binding.name,
                );
                let (super_trait_ref, associated_ty) = match found {
-                    None => return SmallVec::<[WhereClause; 1]>::new(),
+                    None => return SmallVec::<[QuantifiedWhereClause; 1]>::new(),
                    Some(t) => t,
                };
                let projection_ty = ProjectionTy {
@@ -749,12 +768,13 @@ impl<'a> TyLoweringContext<'a> {
                    let ty = self.lower_ty(type_ref);
                    let alias_eq =
                        AliasEq { alias: AliasTy::Projection(projection_ty.clone()), ty };
-                    preds.push(WhereClause::AliasEq(alias_eq));
+                    preds.push(Binders::wrap_empty(WhereClause::AliasEq(alias_eq)));
                }
                for bound in &binding.bounds {
                    preds.extend(self.lower_type_bound(
                        bound,
                        TyKind::Alias(AliasTy::Projection(projection_ty.clone())).intern(&Interner),
+                        false,
                    ));
                }
                preds
@@ -766,7 +786,7 @@ impl<'a> TyLoweringContext<'a> {
        let self_ty =
            TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner);
        let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {
-            bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone())).collect()
+            bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone(), false)).collect()
        });
        ReturnTypeImplTrait { bounds: Binders::new(1, predicates) }
    }
@@ -805,7 +825,7 @@ pub fn associated_type_shorthand_candidates<R>(
            let predicates = db.generic_predicates_for_param(param_id);
            let mut traits_: Vec<_> = predicates
                .iter()
-                .filter_map(|pred| match &pred.value {
+                .filter_map(|pred| match &pred.value.value {
                    WhereClause::Implemented(tr) => Some(tr.clone()),
                    _ => None,
                })
@@ -878,7 +898,7 @@ pub(crate) fn field_types_query(
 pub(crate) fn generic_predicates_for_param_query(
    db: &dyn HirDatabase,
    param_id: TypeParamId,
-) -> Arc<[Binders<WhereClause>]> {
+) -> Arc<[Binders<QuantifiedWhereClause>]> {
    let resolver = param_id.parent.resolver(db.upcast());
    let ctx =
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
@@ -896,7 +916,9 @@ pub(crate) fn generic_predicates_for_param_query(
            },
            WherePredicate::Lifetime { .. } => false,
        })
-        .flat_map(|pred| ctx.lower_where_predicate(pred).map(|p| Binders::new(generics.len(), p)))
+        .flat_map(|pred| {
+            ctx.lower_where_predicate(pred, true).map(|p| Binders::new(generics.len(), p))
+        })
        .collect()
 }
@@ -904,7 +926,7 @@ pub(crate) fn generic_predicates_for_param_recover(
    _db: &dyn HirDatabase,
    _cycle: &[String],
    _param_id: &TypeParamId,
-) -> Arc<[Binders<WhereClause>]> {
+) -> Arc<[Binders<QuantifiedWhereClause>]> {
    Arc::new([])
 }
@@ -918,8 +940,8 @@ pub(crate) fn trait_environment_query(
    let mut traits_in_scope = Vec::new();
    let mut clauses = Vec::new();
    for pred in resolver.where_predicates_in_scope() {
-        for pred in ctx.lower_where_predicate(pred) {
+        for pred in ctx.lower_where_predicate(pred, false) {
-            if let WhereClause::Implemented(tr) = &pred {
+            if let WhereClause::Implemented(tr) = &pred.skip_binders() {
                traits_in_scope.push((tr.self_type_parameter().clone(), tr.hir_trait_id()));
            }
            let program_clause: chalk_ir::ProgramClause<Interner> =
@@ -946,8 +968,7 @@ pub(crate) fn trait_environment_query(
        let substs = Substitution::type_params(db, trait_id);
        let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution: substs };
        let pred = WhereClause::Implemented(trait_ref);
-        let program_clause: chalk_ir::ProgramClause<Interner> =
+        let program_clause: chalk_ir::ProgramClause<Interner> = pred.to_chalk(db).cast(&Interner);
-            pred.clone().to_chalk(db).cast(&Interner);
        clauses.push(program_clause.into_from_env_clause(&Interner));
    }
@@ -960,14 +981,16 @@ pub(crate) fn trait_environment_query(
 pub(crate) fn generic_predicates_query(
    db: &dyn HirDatabase,
    def: GenericDefId,
-) -> Arc<[Binders<WhereClause>]> {
+) -> Arc<[Binders<QuantifiedWhereClause>]> {
    let resolver = def.resolver(db.upcast());
    let ctx =
        TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable);
    let generics = generics(db.upcast(), def);
    resolver
        .where_predicates_in_scope()
-        .flat_map(|pred| ctx.lower_where_predicate(pred).map(|p| Binders::new(generics.len(), p)))
+        .flat_map(|pred| {
+            ctx.lower_where_predicate(pred, false).map(|p| Binders::new(generics.len(), p))
+        })
        .collect()
 }
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index da6bc2a4a..8e986ddde 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -6,7 +6,7 @@ use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
 use base_db::CrateId;
-use chalk_ir::{cast::Cast, Mutability};
+use chalk_ir::{cast::Cast, Mutability, UniverseIndex};
 use hir_def::{
    lang_item::LangItemTarget, AssocContainerId, AssocItemId, FunctionId, GenericDefId, HasModule,
    ImplId, Lookup, ModuleId, TraitId,
@@ -21,8 +21,9 @@ use crate::{
    primitive::{self, FloatTy, IntTy, UintTy},
    to_chalk_trait_id,
    utils::all_super_traits,
-    AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, ForeignDefId, InEnvironment, Interner,
+    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, FnPointer, FnSig, ForeignDefId,
-    Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
+    InEnvironment, Interner, Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyKind,
+    TypeWalk,
 };
 /// This is used as a key for indexing impls.
@@ -375,7 +376,7 @@ fn iterate_method_candidates_impl(
            // Also note that when we've got a receiver like &S, even if the method we
            // find in the end takes &self, we still do the autoderef step (just as
            // rustc does an autoderef and then autoref again).
-            let ty = InEnvironment { value: ty.clone(), environment: env.clone() };
+            let ty = InEnvironment { goal: ty.clone(), environment: env.env.clone() };
            // We have to be careful about the order we're looking at candidates
            // in here. Consider the case where we're resolving `x.clone()`
@@ -443,7 +444,7 @@ fn iterate_method_candidates_with_autoref(
        return true;
    }
    let refed = Canonical {
-        kinds: deref_chain[0].kinds.clone(),
+        binders: deref_chain[0].binders.clone(),
        value: TyKind::Ref(Mutability::Not, deref_chain[0].value.clone()).intern(&Interner),
    };
    if iterate_method_candidates_by_receiver(
@@ -459,7 +460,7 @@ fn iterate_method_candidates_with_autoref(
        return true;
    }
    let ref_muted = Canonical {
-        kinds: deref_chain[0].kinds.clone(),
+        binders: deref_chain[0].binders.clone(),
        value: TyKind::Ref(Mutability::Mut, deref_chain[0].value.clone()).intern(&Interner),
    };
    if iterate_method_candidates_by_receiver(
@@ -621,7 +622,7 @@ pub fn resolve_indexing_op(
    krate: CrateId,
    index_trait: TraitId,
 ) -> Option<Canonical<Ty>> {
-    let ty = InEnvironment { value: ty.clone(), environment: env.clone() };
+    let ty = InEnvironment { goal: ty.clone(), environment: env.env.clone() };
    let deref_chain = autoderef_method_receiver(db, krate, ty);
    for ty in deref_chain {
        let goal = generic_implements_goal(db, env.clone(), index_trait, ty.clone());
@@ -677,19 +678,28 @@ pub(crate) fn inherent_impl_substs(
    // we create a var for each type parameter of the impl; we need to keep in
    // mind here that `self_ty` might have vars of its own
    let vars = Substitution::build_for_def(db, impl_id)
-        .fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.kinds.len())
+        .fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.binders.len(&Interner))
        .build();
    let self_ty_with_vars = db.impl_self_ty(impl_id).subst(&vars);
-    let mut kinds = self_ty.kinds.to_vec();
+    let mut kinds = self_ty.binders.interned().to_vec();
-    kinds.extend(iter::repeat(chalk_ir::TyVariableKind::General).take(vars.len()));
+    kinds.extend(
-    let tys = Canonical { kinds: kinds.into(), value: (self_ty_with_vars, self_ty.value.clone()) };
+        iter::repeat(chalk_ir::WithKind::new(
+            chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
+            UniverseIndex::ROOT,
+        ))
+        .take(vars.len()),
+    );
+    let tys = Canonical {
+        binders: CanonicalVarKinds::from_iter(&Interner, kinds),
+        value: (self_ty_with_vars, self_ty.value.clone()),
+    };
    let substs = super::infer::unify(&tys);
    // We only want the substs for the vars we added, not the ones from self_ty.
    // Also, if any of the vars we added are still in there, we replace them by
    // Unknown. I think this can only really happen if self_ty contained
    // Unknown, and in that case we want the result to contain Unknown in those
    // places again.
-    substs.map(|s| fallback_bound_vars(s.suffix(vars.len()), self_ty.kinds.len()))
+    substs.map(|s| fallback_bound_vars(s.suffix(vars.len()), self_ty.binders.len(&Interner)))
 }
 /// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
@@ -768,15 +778,24 @@ fn generic_implements_goal(
    trait_: TraitId,
    self_ty: Canonical<Ty>,
 ) -> Canonical<InEnvironment<super::DomainGoal>> {
-    let mut kinds = self_ty.kinds.to_vec();
+    let mut kinds = self_ty.binders.interned().to_vec();
    let substs = super::Substitution::build_for_def(db, trait_)
        .push(self_ty.value)
        .fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len())
        .build();
-    kinds.extend(iter::repeat(chalk_ir::TyVariableKind::General).take(substs.len() - 1));
+    kinds.extend(
+        iter::repeat(chalk_ir::WithKind::new(
+            chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
+            UniverseIndex::ROOT,
+        ))
+        .take(substs.len() - 1),
+    );
    let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_), substitution: substs };
    let obligation = trait_ref.cast(&Interner);
-    Canonical { kinds: kinds.into(), value: InEnvironment::new(env, obligation) }
+    Canonical {
+        binders: CanonicalVarKinds::from_iter(&Interner, kinds),
+        value: InEnvironment::new(env.env.clone(), obligation),
+    }
 }
 fn autoderef_method_receiver(
@@ -789,9 +808,9 @@ fn autoderef_method_receiver(
    if let Some(TyKind::Array(parameters)) =
        deref_chain.last().map(|ty| ty.value.interned(&Interner))
    {
-        let kinds = deref_chain.last().unwrap().kinds.clone();
+        let kinds = deref_chain.last().unwrap().binders.clone();
        let unsized_ty = TyKind::Slice(parameters.clone()).intern(&Interner);
-        deref_chain.push(Canonical { value: unsized_ty, kinds })
+        deref_chain.push(Canonical { value: unsized_ty, binders: kinds })
    }
    deref_chain
 }
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index 0a4141e69..ad283c1e0 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -369,3 +369,72 @@ fn check_infer_with_mismatches(ra_fixture: &str, expect: Expect) {
    actual.push('\n');
    expect.assert_eq(&actual);
 }
+#[test]
+fn salsa_bug() {
+    let (mut db, pos) = TestDB::with_position(
+        "
+        //- /lib.rs
+        trait Index {
+            type Output;
+        }
+        type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key;
+        pub trait UnificationStoreBase: Index<Output = Key<Self>> {
+            type Key;
+            fn len(&self) -> usize;
+        }
+        pub trait UnificationStoreMut: UnificationStoreBase {
+            fn push(&mut self, value: Self::Key);
+        }
+        fn main() {
+            let x = 1;
+            x.push(1);$0
+        }
+    ",
+    );
+    let module = db.module_for_file(pos.file_id);
+    let crate_def_map = module.def_map(&db);
+    visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
+        db.infer(def);
+    });
+    let new_text = "
+        //- /lib.rs
+        trait Index {
+            type Output;
+        }
+        type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key;
+        pub trait UnificationStoreBase: Index<Output = Key<Self>> {
+            type Key;
+            fn len(&self) -> usize;
+        }
+        pub trait UnificationStoreMut: UnificationStoreBase {
+            fn push(&mut self, value: Self::Key);
+        }
+        fn main() {
+            let x = 1;
+            x.push(1);
+        }
+    "
+    .to_string();
+    db.set_file_text(pos.file_id, Arc::new(new_text));
+    let module = db.module_for_file(pos.file_id);
+    let crate_def_map = module.def_map(&db);
+    visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
+        db.infer(def);
+    });
+}
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index c1e605740..12951fb16 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -607,6 +607,29 @@ fn bar() -> u32 {0}
 }
 #[test]
+fn infer_builtin_macros_include_child_mod() {
+    check_types(
+        r#"
+//- /main.rs
+#[rustc_builtin_macro]
+macro_rules! include {() => {}}
+include!("f/foo.rs");
+fn main() {
+    bar::bar();
+}          //^ u32
+//- /f/foo.rs
+pub mod bar;
+//- /f/bar.rs
+pub fn bar() -> u32 {0}
+"#,
+    );
+}
+#[test]
 fn infer_builtin_macros_include_str() {
    check_types(
        r#"
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index 5da19ba5f..85a28e76b 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -658,6 +658,28 @@ fn slice_tail_pattern() {
 fn box_pattern() {
    check_infer(
        r#"
+        pub struct Global;
+        #[lang = "owned_box"]
+        pub struct Box<T, A = Global>(T);
+        fn foo(params: Box<i32>) {
+            match params {
+                box integer => {}
+            }
+        }
+        "#,
+        expect![[r#"
+            83..89 'params': Box<i32, Global>
+            101..155 '{     ...   } }': ()
+            107..153 'match ...     }': ()
+            113..119 'params': Box<i32, Global>
+            130..141 'box integer': Box<i32, Global>
+            134..141 'integer': i32
+            145..147 '{}': ()
+        "#]],
+    );
+    check_infer(
+        r#"
        #[lang = "owned_box"]
        pub struct Box<T>(T);
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 8f2bdffc0..37cd04c6f 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -2272,6 +2272,56 @@ fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
 }
 #[test]
+fn unselected_projection_in_trait_env_cycle_3() {
+    // this is a cycle for rustc; we currently accept it
+    check_types(
+        r#"
+//- /main.rs
+trait Trait {
+    type Item;
+    type OtherItem;
+}
+fn test<T>() where T: Trait<OtherItem = T::Item> {
+    let x: T::Item = no_matter;
+}                   //^ Trait::Item<T>
+"#,
+    );
+}
+#[test]
+fn unselected_projection_in_trait_env_no_cycle() {
+    // this is not a cycle
+    check_types(
+        r#"
+//- /main.rs
+trait Index {
+    type Output;
+}
+type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key;
+pub trait UnificationStoreBase: Index<Output = Key<Self>> {
+    type Key;
+    fn len(&self) -> usize;
+}
+pub trait UnificationStoreMut: UnificationStoreBase {
+    fn push(&mut self, value: Self::Key);
+}
+fn test<T>(t: T) where T: UnificationStoreMut {
+    let x;
+    t.push(x);
+    let y: Key<T>;
+    (x, y);
+}      //^ (UnificationStoreBase::Key<T>, UnificationStoreBase::Key<T>)
+"#,
+    );
+}
+#[test]
 fn inline_assoc_type_bounds_1() {
    check_types(
        r#"
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index 7dadd1ffb..ccee0e5ad 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -1,6 +1,5 @@
 //! Trait solving using Chalk.
 use std::env::var;
-use std::sync::Arc;
 use base_db::CrateId;
 use chalk_ir::cast::Cast;
@@ -44,7 +43,7 @@ pub struct TraitEnvironment {
    // When we're using Chalk's Ty we can make this a BTreeMap since it's Ord,
    // but for now it's too annoying...
    pub(crate) traits_from_clauses: Vec<(Ty, TraitId)>,
-    pub(crate) env: chalk_ir::Environment<Interner>,
+    pub env: chalk_ir::Environment<Interner>,
 }
 impl TraitEnvironment {
@@ -74,13 +73,13 @@ impl Default for TraitEnvironment {
 /// Something (usually a goal), along with an environment.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct InEnvironment<T> {
-    pub environment: Arc<TraitEnvironment>,
+    pub environment: chalk_ir::Environment<Interner>,
-    pub value: T,
+    pub goal: T,
 }
 impl<T> InEnvironment<T> {
-    pub fn new(environment: Arc<TraitEnvironment>, value: T) -> InEnvironment<T> {
+    pub fn new(environment: chalk_ir::Environment<Interner>, value: T) -> InEnvironment<T> {
-        InEnvironment { environment, value }
+        InEnvironment { environment, goal: value }
    }
 }
@@ -126,18 +125,18 @@ pub(crate) fn trait_solve_query(
    krate: CrateId,
    goal: Canonical<InEnvironment<DomainGoal>>,
 ) -> Option<Solution> {
-    let _p = profile::span("trait_solve_query").detail(|| match &goal.value.value {
+    let _p = profile::span("trait_solve_query").detail(|| match &goal.value.goal {
        DomainGoal::Holds(WhereClause::Implemented(it)) => {
            db.trait_data(it.hir_trait_id()).name.to_string()
        }
        DomainGoal::Holds(WhereClause::AliasEq(_)) => "alias_eq".to_string(),
    });
-    log::info!("trait_solve_query({})", goal.value.value.display(db));
+    log::info!("trait_solve_query({})", goal.value.goal.display(db));
    if let DomainGoal::Holds(WhereClause::AliasEq(AliasEq {
        alias: AliasTy::Projection(projection_ty),
        ..
-    })) = &goal.value.value
+    })) = &goal.value.goal
    {
        if let TyKind::BoundVar(_) = &projection_ty.substitution[0].interned(&Interner) {
            // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 734679414..4019fdf17 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -238,7 +238,10 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                    });
                    let bound = OpaqueTyDatumBound {
                        bounds: make_binders(
-                            vec![impl_bound.to_chalk(self.db), proj_bound.to_chalk(self.db)],
+                            vec![
+                                wrap_in_empty_binders(impl_bound).to_chalk(self.db),
+                                wrap_in_empty_binders(proj_bound).to_chalk(self.db),
+                            ],
                            1,
                        ),
                        where_clauses: make_binders(vec![], 0),
@@ -395,9 +398,8 @@ pub(crate) fn associated_ty_data_query(
    let bounds = type_alias_data
        .bounds
        .iter()
-        .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone()))
+        .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone(), false))
        .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty))
-        .map(|bound| make_binders(bound.shifted_in(&Interner), 0))
        .collect();
    let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
@@ -720,3 +722,7 @@ impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> {
        chalk_ir::ClosureId(id.as_intern_id())
    }
 }
+fn wrap_in_empty_binders<T: crate::TypeWalk>(value: T) -> crate::Binders<T> {
+    crate::Binders::wrap_empty(value)
+}
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 65feb82e5..aef6b8a15 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -7,15 +7,14 @@ use chalk_ir::{cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeDa
 use chalk_solve::rust_ir;
 use base_db::salsa::InternKey;
-use hir_def::{AssocContainerId, GenericDefId, Lookup, TypeAliasId};
+use hir_def::{GenericDefId, TypeAliasId};
 use crate::{
    db::HirDatabase,
-    from_assoc_type_id,
    primitive::UintTy,
    traits::{Canonical, DomainGoal},
-    AliasTy, CallableDefId, FnPointer, InEnvironment, OpaqueTy, ProjectionTy, Scalar, Substitution,
+    AliasTy, CallableDefId, FnPointer, InEnvironment, OpaqueTy, ProjectionTy,
-    TraitRef, Ty, WhereClause,
+    QuantifiedWhereClause, Scalar, Substitution, TraitRef, Ty, TypeWalk, WhereClause,
 };
 use super::interner::*;
@@ -95,10 +94,10 @@ impl ToChalk for Ty {
            TyKind::Placeholder(idx) => idx.to_ty::<Interner>(&Interner),
            TyKind::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
            TyKind::InferenceVar(..) => panic!("uncanonicalized infer ty"),
-            TyKind::Dyn(predicates) => {
+            TyKind::Dyn(dyn_ty) => {
                let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter(
                    &Interner,
-                    predicates.iter().cloned().map(|p| p.to_chalk(db)),
+                    dyn_ty.bounds.value.interned().iter().cloned().map(|p| p.to_chalk(db)),
                );
                let bounded_ty = chalk_ir::DynTy {
                    bounds: make_binders(where_clauses, 1),
@@ -144,13 +143,17 @@ impl ToChalk for Ty {
            chalk_ir::TyKind::InferenceVar(_iv, _kind) => TyKind::Unknown,
            chalk_ir::TyKind::Dyn(where_clauses) => {
                assert_eq!(where_clauses.bounds.binders.len(&Interner), 1);
-                let predicates = where_clauses
+                let bounds = where_clauses
                    .bounds
                    .skip_binders()
                    .iter(&Interner)
-                    .map(|c| from_chalk(db, c.clone()))
+                    .map(|c| from_chalk(db, c.clone()));
-                    .collect();
+                TyKind::Dyn(crate::DynTy {
-                TyKind::Dyn(predicates)
+                    bounds: crate::Binders::new(
+                        1,
+                        crate::QuantifiedWhereClauses::from_iter(&Interner, bounds),
+                    ),
+                })
            }
            chalk_ir::TyKind::Adt(adt_id, subst) => TyKind::Adt(adt_id, from_chalk(db, subst)),
@@ -305,33 +308,22 @@ impl ToChalk for TypeAliasAsValue {
 }
 impl ToChalk for WhereClause {
-    type Chalk = chalk_ir::QuantifiedWhereClause<Interner>;
+    type Chalk = chalk_ir::WhereClause<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::QuantifiedWhereClause<Interner> {
+    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::WhereClause<Interner> {
        match self {
            WhereClause::Implemented(trait_ref) => {
-                let chalk_trait_ref = trait_ref.to_chalk(db);
+                chalk_ir::WhereClause::Implemented(trait_ref.to_chalk(db))
-                let chalk_trait_ref = chalk_trait_ref.shifted_in(&Interner);
-                make_binders(chalk_ir::WhereClause::Implemented(chalk_trait_ref), 0)
            }
-            WhereClause::AliasEq(alias_eq) => make_binders(
+            WhereClause::AliasEq(alias_eq) => chalk_ir::WhereClause::AliasEq(alias_eq.to_chalk(db)),
-                chalk_ir::WhereClause::AliasEq(alias_eq.to_chalk(db).shifted_in(&Interner)),
-                0,
-            ),
        }
    }
    fn from_chalk(
        db: &dyn HirDatabase,
-        where_clause: chalk_ir::QuantifiedWhereClause<Interner>,
+        where_clause: chalk_ir::WhereClause<Interner>,
    ) -> WhereClause {
-        // we don't produce any where clauses with binders and can't currently deal with them
+        match where_clause {
-        match where_clause
-            .skip_binders()
-            .clone()
-            .shifted_out(&Interner)
-            .expect("unexpected bound vars in where clause")
-        {
            chalk_ir::WhereClause::Implemented(tr) => WhereClause::Implemented(from_chalk(db, tr)),
            chalk_ir::WhereClause::AliasEq(alias_eq) => {
                WhereClause::AliasEq(from_chalk(db, alias_eq))
@@ -447,35 +439,12 @@ where
    type Chalk = chalk_ir::Canonical<T::Chalk>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Canonical<T::Chalk> {
-        let kinds = self.kinds.iter().map(|&tk| {
-            chalk_ir::CanonicalVarKind::new(
-                chalk_ir::VariableKind::Ty(tk),
-                chalk_ir::UniverseIndex::ROOT,
-            )
-        });
        let value = self.value.to_chalk(db);
-        chalk_ir::Canonical {
+        chalk_ir::Canonical { value, binders: self.binders }
-            value,
-            binders: chalk_ir::CanonicalVarKinds::from_iter(&Interner, kinds),
-        }
    }
    fn from_chalk(db: &dyn HirDatabase, canonical: chalk_ir::Canonical<T::Chalk>) -> Canonical<T> {
-        let kinds = canonical
+        Canonical { binders: canonical.binders, value: from_chalk(db, canonical.value) }
-            .binders
-            .iter(&Interner)
-            .map(|k| match k.kind {
-                chalk_ir::VariableKind::Ty(tk) => tk,
-                // HACK: Chalk can sometimes return new lifetime variables. We
-                // want to just skip them, but to not mess up the indices of
-                // other variables, we'll just create a new type variable in
-                // their place instead. This should not matter (we never see the
-                // actual *uses* of the lifetime variable).
-                chalk_ir::VariableKind::Lifetime => chalk_ir::TyVariableKind::General,
-                chalk_ir::VariableKind::Const(_) => panic!("unexpected const from Chalk"),
-            })
-            .collect();
-        Canonical { kinds, value: from_chalk(db, canonical.value) }
    }
 }
@@ -486,10 +455,7 @@ where
    type Chalk = chalk_ir::InEnvironment<T::Chalk>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::InEnvironment<T::Chalk> {
-        chalk_ir::InEnvironment {
+        chalk_ir::InEnvironment { environment: self.environment, goal: self.goal.to_chalk(db) }
-            environment: self.environment.env.clone(),
-            goal: self.value.to_chalk(db),
-        }
    }
    fn from_chalk(
@@ -500,6 +466,29 @@ where
    }
 }
+impl<T: ToChalk> ToChalk for crate::Binders<T>
+where
+    T::Chalk: chalk_ir::interner::HasInterner<Interner = Interner>,
+{
+    type Chalk = chalk_ir::Binders<T::Chalk>;
+    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Binders<T::Chalk> {
+        chalk_ir::Binders::new(
+            chalk_ir::VariableKinds::from_iter(
+                &Interner,
+                std::iter::repeat(chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General))
+                    .take(self.num_binders),
+            ),
+            self.value.to_chalk(db),
+        )
+    }
+    fn from_chalk(db: &dyn HirDatabase, binders: chalk_ir::Binders<T::Chalk>) -> crate::Binders<T> {
+        let (v, b) = binders.into_value_and_skipped_binders();
+        crate::Binders::new(b.len(&Interner), from_chalk(db, v))
+    }
+}
 pub(super) fn make_binders<T>(value: T, num_vars: usize) -> chalk_ir::Binders<T>
 where
    T: HasInterner<Interner = Interner>,
@@ -529,14 +518,15 @@ pub(super) fn convert_where_clauses(
 pub(super) fn generic_predicate_to_inline_bound(
    db: &dyn HirDatabase,
-    pred: &WhereClause,
+    pred: &QuantifiedWhereClause,
    self_ty: &Ty,
-) -> Option<rust_ir::InlineBound<Interner>> {
+) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
    // An InlineBound is like a GenericPredicate, except the self type is left out.
    // We don't have a special type for this, but Chalk does.
-    match pred {
+    let self_ty_shifted_in = self_ty.clone().shift_bound_vars(DebruijnIndex::ONE);
+    match &pred.value {
        WhereClause::Implemented(trait_ref) => {
-            if &trait_ref.substitution[0] != self_ty {
+            if trait_ref.self_type_parameter() != &self_ty_shifted_in {
                // we can only convert predicates back to type bounds if they
                // have the expected self type
                return None;
@@ -546,19 +536,13 @@ pub(super) fn generic_predicate_to_inline_bound(
                .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
                .collect();
            let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
-            Some(rust_ir::InlineBound::TraitBound(trait_bound))
+            Some(make_binders(rust_ir::InlineBound::TraitBound(trait_bound), pred.num_binders))
        }
        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
-            if &projection_ty.substitution[0] != self_ty {
+            if projection_ty.self_type_parameter() != &self_ty_shifted_in {
                return None;
            }
-            let trait_ = match from_assoc_type_id(projection_ty.associated_ty_id)
+            let trait_ = projection_ty.trait_(db);
-                .lookup(db.upcast())
-                .container
-            {
-                AssocContainerId::TraitId(t) => t,
-                _ => panic!("associated type not in trait"),
-            };
            let args_no_self = projection_ty.substitution[1..]
                .iter()
                .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
@@ -569,7 +553,7 @@ pub(super) fn generic_predicate_to_inline_bound(
                associated_ty_id: projection_ty.associated_ty_id,
                parameters: Vec::new(), // FIXME we don't support generic associated types yet
            };
-            Some(rust_ir::InlineBound::AliasEqBound(alias_eq_bound))
+            Some(make_binders(rust_ir::InlineBound::AliasEqBound(alias_eq_bound), pred.num_binders))
        }
        _ => None,
    }
diff --git a/crates/hir_ty/src/utils.rs b/crates/hir_ty/src/utils.rs
index 1ec1ecd43..19874e42b 100644
--- a/crates/hir_ty/src/utils.rs
+++ b/crates/hir_ty/src/utils.rs
@@ -63,7 +63,7 @@ fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef) -> Vec<Tr
    db.generic_predicates_for_param(trait_self)
        .iter()
        .filter_map(|pred| {
-            pred.as_ref().filter_map(|pred| match pred {
+            pred.as_ref().filter_map(|pred| match pred.skip_binders() {
                WhereClause::Implemented(tr) => Some(tr.clone()),
                _ => None,
            })
diff --git a/crates/ide/src/extend_selection.rs b/crates/ide/src/extend_selection.rs
index e187243cb..5201ce587 100644
--- a/crates/ide/src/extend_selection.rs
+++ b/crates/ide/src/extend_selection.rs
@@ -263,11 +263,10 @@ fn extend_list_item(node: &SyntaxNode) -> Option<TextRange> {
    ) -> Option<SyntaxToken> {
        node.siblings_with_tokens(dir)
            .skip(1)
-            .skip_while(|node| match node {
+            .find(|node| match node {
-                NodeOrToken::Node(_) => false,
+                NodeOrToken::Node(_) => true,
-                NodeOrToken::Token(it) => is_single_line_ws(it),
+                NodeOrToken::Token(it) => !is_single_line_ws(it),
            })
-            .next()
            .and_then(|it| it.into_token())
            .filter(|node| node.kind() == delimiter_kind)
    }
diff --git a/crates/ide_assists/src/handlers/convert_comment_block.rs b/crates/ide_assists/src/handlers/convert_comment_block.rs
index cdc45fc42..9dc3ee28f 100644
--- a/crates/ide_assists/src/handlers/convert_comment_block.rs
+++ b/crates/ide_assists/src/handlers/convert_comment_block.rs
@@ -1,5 +1,4 @@
 use itertools::Itertools;
-use std::convert::identity;
 use syntax::{
    ast::{
        self,
@@ -140,7 +139,7 @@ fn relevant_line_comments(comment: &ast::Comment) -> Vec<Comment> {
        .filter(|s| !skippable(s))
        .map(|not| not.into_token().and_then(Comment::cast).filter(same_prefix))
        .take_while(|opt_com| opt_com.is_some())
-        .filter_map(identity)
+        .flatten()
        .skip(1); // skip the first element so we don't duplicate it in next_comments
    let next_comments = comment
@@ -149,7 +148,7 @@ fn relevant_line_comments(comment: &ast::Comment) -> Vec<Comment> {
        .filter(|s| !skippable(s))
        .map(|not| not.into_token().and_then(Comment::cast).filter(same_prefix))
        .take_while(|opt_com| opt_com.is_some())
-        .filter_map(identity);
+        .flatten();
    let mut comments: Vec<_> = prev_comments.collect();
    comments.reverse();
diff --git a/crates/ide_assists/src/handlers/expand_glob_import.rs b/crates/ide_assists/src/handlers/expand_glob_import.rs
index 83aa11d52..98389e4f7 100644
--- a/crates/ide_assists/src/handlers/expand_glob_import.rs
+++ b/crates/ide_assists/src/handlers/expand_glob_import.rs
@@ -136,18 +136,13 @@ impl Refs {
                .into_iter()
                .filter(|r| {
                    if let Def::ModuleDef(ModuleDef::Trait(tr)) = r.def {
-                        if tr
+                        if tr.items(ctx.db()).into_iter().any(|ai| {
-                            .items(ctx.db())
+                            if let AssocItem::Function(f) = ai {
-                            .into_iter()
+                                Def::ModuleDef(ModuleDef::Function(f)).is_referenced_in(ctx)
-                            .find(|ai| {
+                            } else {
-                                if let AssocItem::Function(f) = *ai {
+                                false
-                                    Def::ModuleDef(ModuleDef::Function(f)).is_referenced_in(ctx)
+                            }
-                                } else {
+                        }) {
-                                    false
-                                }
-                            })
-                            .is_some()
-                        {
                            return true;
                        }
                    }
diff --git a/crates/ide_assists/src/handlers/reorder_impl.rs b/crates/ide_assists/src/handlers/reorder_impl.rs
index edf4b0bfe..f976e73ad 100644
--- a/crates/ide_assists/src/handlers/reorder_impl.rs
+++ b/crates/ide_assists/src/handlers/reorder_impl.rs
@@ -95,7 +95,7 @@ fn compute_method_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashM
                _ => None,
            })
            .enumerate()
-            .map(|(idx, func)| ((func.name(ctx.db()).to_string(), idx)))
+            .map(|(idx, func)| (func.name(ctx.db()).to_string(), idx))
            .collect(),
    )
 }
diff --git a/crates/ide_completion/src/completions/lifetime.rs b/crates/ide_completion/src/completions/lifetime.rs
index 628c1fb9b..5eeddf7a4 100644
--- a/crates/ide_completion/src/completions/lifetime.rs
+++ b/crates/ide_completion/src/completions/lifetime.rs
@@ -70,6 +70,16 @@ fn func<'lifetime>(foo: &'li$0) {}
 fn func<'lifetime>(foo: &'lifetime) {}
 "#,
        );
+        cov_mark::check!(completes_if_lifetime_without_idents);
+        check_edit(
+            "'lifetime",
+            r#"
+fn func<'lifetime>(foo: &'$0) {}
+"#,
+            r#"
+fn func<'lifetime>(foo: &'lifetime) {}
+"#,
+        );
    }
    #[test]
@@ -192,6 +202,27 @@ fn foo<'footime, 'lifetime: 'a$0>() {}
    }
    #[test]
+    fn check_label_edit() {
+        check_edit(
+            "'label",
+            r#"
+fn foo() {
+    'label: loop {
+        break '$0
+    }
+}
+"#,
+            r#"
+fn foo() {
+    'label: loop {
+        break 'label
+    }
+}
+"#,
+        );
+    }
+    #[test]
    fn complete_label_in_loop() {
        check(
            r#"
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 67e2d6f6c..32f81aec1 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -255,6 +255,10 @@ impl<'a> CompletionContext<'a> {
        if kind == IDENT || kind == LIFETIME_IDENT || kind == UNDERSCORE || kind.is_keyword() {
            cov_mark::hit!(completes_if_prefix_is_keyword);
            self.original_token.text_range()
+        } else if kind == CHAR {
+            // assume we are completing a lifetime but the user has only typed the '
+            cov_mark::hit!(completes_if_lifetime_without_idents);
+            TextRange::at(self.original_token.text_range().start(), TextSize::from(1))
        } else {
            TextRange::empty(self.position.offset)
        }
@@ -471,7 +475,7 @@ impl<'a> CompletionContext<'a> {
        self.lifetime_syntax =
            find_node_at_offset(original_file, lifetime.syntax().text_range().start());
        if let Some(parent) = lifetime.syntax().parent() {
-            if parent.kind() == syntax::SyntaxKind::ERROR {
+            if parent.kind() == ERROR {
                return;
            }
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index cf5ef07b7..d82564381 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -71,7 +71,7 @@ fn test_has_block_expr_parent() {
 }
 pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
-    element.ancestors().find(|it| it.kind() == IDENT_PAT).is_some()
+    element.ancestors().any(|it| it.kind() == IDENT_PAT)
 }
 #[test]
 fn test_has_bind_pat_parent() {
diff --git a/crates/ide_db/src/helpers/insert_use.rs b/crates/ide_db/src/helpers/insert_use.rs
index 9e0cb91c3..37acf95f0 100644
--- a/crates/ide_db/src/helpers/insert_use.rs
+++ b/crates/ide_db/src/helpers/insert_use.rs
@@ -14,10 +14,12 @@ use syntax::{
    AstToken, InsertPosition, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxToken,
 };
+pub use hir::PrefixKind;
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct InsertUseConfig {
    pub merge: Option<MergeBehavior>,
-    pub prefix_kind: hir::PrefixKind,
+    pub prefix_kind: PrefixKind,
    pub group: bool,
 }
diff --git a/crates/ide_ssr/src/parsing.rs b/crates/ide_ssr/src/parsing.rs
index 5ff25cb6d..5e757e701 100644
--- a/crates/ide_ssr/src/parsing.rs
+++ b/crates/ide_ssr/src/parsing.rs
@@ -67,7 +67,7 @@ impl ParsedRule {
    ) -> Result<Vec<ParsedRule>, SsrError> {
        let raw_pattern = pattern.as_rust_code();
        let raw_template = template.map(|t| t.as_rust_code());
-        let raw_template = raw_template.as_ref().map(|s| s.as_str());
+        let raw_template = raw_template.as_deref();
        let mut builder = RuleBuilder {
            placeholders_by_stand_in: pattern.placeholders_by_stand_in(),
            rules: Vec::new(),
diff --git a/crates/mbe/src/expander/matcher.rs b/crates/mbe/src/expander/matcher.rs
index 1682b21b0..75d2f2eed 100644
--- a/crates/mbe/src/expander/matcher.rs
+++ b/crates/mbe/src/expander/matcher.rs
@@ -304,7 +304,7 @@ impl BindingsBuilder {
        link_nodes: &'a Vec<LinkNode<Rc<BindingKind>>>,
        nodes: &mut Vec<&'a Rc<BindingKind>>,
    ) {
-        link_nodes.into_iter().for_each(|it| match it {
+        link_nodes.iter().for_each(|it| match it {
            LinkNode::Node(it) => nodes.push(it),
            LinkNode::Parent { idx, len } => self.collect_nodes_ref(*idx, *len, nodes),
        });
@@ -713,10 +713,9 @@ fn match_meta_var(kind: &str, input: &mut TtIter) -> ExpandResult<Option<Fragmen
                    .map(|ident| Some(tt::Leaf::from(ident.clone()).into()))
                    .map_err(|()| err!("expected ident")),
                "tt" => input.expect_tt().map(Some).map_err(|()| err!()),
-                "lifetime" => input
+                "lifetime" => {
-                    .expect_lifetime()
+                    input.expect_lifetime().map(Some).map_err(|()| err!("expected lifetime"))
-                    .map(|tt| Some(tt))
+                }
-                    .map_err(|()| err!("expected lifetime")),
                "literal" => {
                    let neg = input.eat_char('-');
                    input
diff --git a/crates/mbe/src/lib.rs b/crates/mbe/src/lib.rs
index 33b85e23d..e74f8cf3f 100644
--- a/crates/mbe/src/lib.rs
+++ b/crates/mbe/src/lib.rs
@@ -356,6 +356,6 @@ impl<T> ExpandResult<T> {
 impl<T: Default> From<Result<T, ExpandError>> for ExpandResult<T> {
    fn from(result: Result<T, ExpandError>) -> Self {
-        result.map_or_else(|e| Self::only_err(e), |it| Self::ok(it))
+        result.map_or_else(Self::only_err, Self::ok)
    }
 }
diff --git a/crates/mbe/src/parser.rs b/crates/mbe/src/parser.rs
index c88387653..61b2a4955 100644
--- a/crates/mbe/src/parser.rs
+++ b/crates/mbe/src/parser.rs
@@ -57,7 +57,7 @@ impl<'a> Iterator for OpDelimitedIter<'a> {
    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.inner.len() + if self.delimited.is_some() { 2 } else { 0 };
-        let remain = len.checked_sub(self.idx).unwrap_or(0);
+        let remain = len.saturating_sub(self.idx);
        (remain, Some(remain))
    }
 }
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index 8bba3d3d5..9d433b3b0 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -362,7 +362,7 @@ trait TokenConvertor {
            if let Some((kind, closed)) = delim {
                let mut subtree = tt::Subtree::default();
                let (id, idx) = self.id_alloc().open_delim(range);
-                subtree.delimiter = Some(tt::Delimiter { kind, id });
+                subtree.delimiter = Some(tt::Delimiter { id, kind });
                while self.peek().map(|it| it.kind() != closed).unwrap_or(false) {
                    self.collect_leaf(&mut subtree.token_trees);
diff --git a/crates/mbe/src/tests/expand.rs b/crates/mbe/src/tests/expand.rs
index 2cce62781..8951f3813 100644
--- a/crates/mbe/src/tests/expand.rs
+++ b/crates/mbe/src/tests/expand.rs
@@ -1225,8 +1225,7 @@ macro_rules! m {
    )
    .expand_statements(r#"m!(C("0"))"#)
    .descendants()
-    .find(|token| token.kind() == ERROR)
+    .any(|token| token.kind() == ERROR));
-    .is_some());
 }
 #[test]
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
index 728a258ea..f7050be4e 100644
--- a/crates/project_model/src/build_data.rs
+++ b/crates/project_model/src/build_data.rs
@@ -137,60 +137,53 @@ fn collect_from_workspace(
    let stdout = BufReader::new(child_stdout);
    let mut res = BuildDataMap::default();
-    for message in cargo_metadata::Message::parse_stream(stdout) {
+    for message in cargo_metadata::Message::parse_stream(stdout).flatten() {
-        if let Ok(message) = message {
+        match message {
-            match message {
+            Message::BuildScriptExecuted(BuildScript {
-                Message::BuildScriptExecuted(BuildScript {
+                package_id, out_dir, cfgs, env, ..
-                    package_id,
+            }) => {
-                    out_dir,
+                let cfgs = {
-                    cfgs,
+                    let mut acc = Vec::new();
-                    env,
+                    for cfg in cfgs {
-                    ..
+                        match cfg.parse::<CfgFlag>() {
-                }) => {
+                            Ok(it) => acc.push(it),
-                    let cfgs = {
+                            Err(err) => {
-                        let mut acc = Vec::new();
+                                anyhow::bail!("invalid cfg from cargo-metadata: {}", err)
-                        for cfg in cfgs {
+                            }
-                            match cfg.parse::<CfgFlag>() {
+                        };
-                                Ok(it) => acc.push(it),
-                                Err(err) => {
-                                    anyhow::bail!("invalid cfg from cargo-metadata: {}", err)
-                                }
-                            };
-                        }
-                        acc
-                    };
-                    let res = res.entry(package_id.repr.clone()).or_default();
-                    // cargo_metadata crate returns default (empty) path for
-                    // older cargos, which is not absolute, so work around that.
-                    if !out_dir.as_str().is_empty() {
-                        let out_dir = AbsPathBuf::assert(PathBuf::from(out_dir.into_os_string()));
-                        res.out_dir = Some(out_dir);
-                        res.cfgs = cfgs;
                    }
+                    acc
-                    res.envs = env;
+                };
+                let res = res.entry(package_id.repr.clone()).or_default();
+                // cargo_metadata crate returns default (empty) path for
+                // older cargos, which is not absolute, so work around that.
+                if !out_dir.as_str().is_empty() {
+                    let out_dir = AbsPathBuf::assert(PathBuf::from(out_dir.into_os_string()));
+                    res.out_dir = Some(out_dir);
+                    res.cfgs = cfgs;
                }
-                Message::CompilerArtifact(message) => {
-                    progress(format!("metadata {}", message.target.name));
+                res.envs = env;
+            }
-                    if message.target.kind.contains(&"proc-macro".to_string()) {
+            Message::CompilerArtifact(message) => {
-                        let package_id = message.package_id;
+                progress(format!("metadata {}", message.target.name));
-                        // Skip rmeta file
-                        if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name))
+                if message.target.kind.contains(&"proc-macro".to_string()) {
-                        {
+                    let package_id = message.package_id;
-                            let filename = AbsPathBuf::assert(PathBuf::from(&filename));
+                    // Skip rmeta file
-                            let res = res.entry(package_id.repr.clone()).or_default();
+                    if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name)) {
-                            res.proc_macro_dylib_path = Some(filename);
+                        let filename = AbsPathBuf::assert(PathBuf::from(&filename));
-                        }
+                        let res = res.entry(package_id.repr.clone()).or_default();
+                        res.proc_macro_dylib_path = Some(filename);
                    }
                }
-                Message::CompilerMessage(message) => {
-                    progress(message.target.name.clone());
-                }
-                Message::BuildFinished(_) => {}
-                Message::TextLine(_) => {}
-                _ => {}
            }
+            Message::CompilerMessage(message) => {
+                progress(message.target.name.clone());
+            }
+            Message::BuildFinished(_) => {}
+            Message::TextLine(_) => {}
+            _ => {}
        }
    }
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index aa48c455c..7a5bcb8c7 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -33,7 +33,7 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
        hover_provider: Some(HoverProviderCapability::Simple(true)),
        completion_provider: Some(CompletionOptions {
            resolve_provider: completions_resolve_provider(client_caps),
-            trigger_characters: Some(vec![":".to_string(), ".".to_string()]),
+            trigger_characters: Some(vec![":".to_string(), ".".to_string(), "'".to_string()]),
            all_commit_characters: None,
            completion_item: None,
            work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 8f541976e..5c88c3a9b 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -10,10 +10,9 @@
 use std::{ffi::OsString, iter, path::PathBuf};
 use flycheck::FlycheckConfig;
-use hir::PrefixKind;
 use ide::{AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig};
 use ide_db::helpers::{
-    insert_use::{InsertUseConfig, MergeBehavior},
+    insert_use::{InsertUseConfig, MergeBehavior, PrefixKind},
    SnippetCap,
 };
 use lsp_types::{ClientCapabilities, MarkupKind};
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 984790d35..c63a0eaea 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -242,11 +242,8 @@ impl GlobalState {
                                }
                                BuildDataProgress::End(collector) => {
                                    self.fetch_build_data_completed();
-                                    let workspaces = (*self.workspaces)
+                                    let workspaces =
-                                        .clone()
+                                        (*self.workspaces).clone().into_iter().map(Ok).collect();
-                                        .into_iter()
-                                        .map(|it| Ok(it))
-                                        .collect();
                                    self.switch_workspaces(workspaces, Some(collector));
                                    (Some(Progress::End), None)
                                }
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index aa8504c3d..76fdbcddd 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -237,7 +237,7 @@ impl GlobalState {
            None => None,
        };
-        if &*self.workspaces == &workspaces && self.workspace_build_data == workspace_build_data {
+        if *self.workspaces == workspaces && self.workspace_build_data == workspace_build_data {
            return;
        }
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 1ddea9278..c1ca7ff9b 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -1073,9 +1073,11 @@ pub(crate) fn rename_error(err: RenameError) -> crate::LspError {
 mod tests {
    use std::sync::Arc;
-    use hir::PrefixKind;
    use ide::Analysis;
-    use ide_db::helpers::{insert_use::InsertUseConfig, SnippetCap};
+    use ide_db::helpers::{
+        insert_use::{InsertUseConfig, PrefixKind},
+        SnippetCap,
+    };
    use super::*;
diff --git a/crates/rust-analyzer/tests/rust-analyzer/support.rs b/crates/rust-analyzer/tests/rust-analyzer/support.rs
index cd0c91481..95bf26f01 100644
--- a/crates/rust-analyzer/tests/rust-analyzer/support.rs
+++ b/crates/rust-analyzer/tests/rust-analyzer/support.rs
@@ -54,7 +54,7 @@ impl<'a> Project<'a> {
    }
    pub(crate) fn server(self) -> Server {
-        let tmp_dir = self.tmp_dir.unwrap_or_else(|| TestDir::new());
+        let tmp_dir = self.tmp_dir.unwrap_or_else(TestDir::new);
        static INIT: Once = Once::new();
        INIT.call_once(|| {
            env_logger::builder().is_test(true).parse_env("RA_LOG").try_init().unwrap();
diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index 82ebf9037..a153a9e1c 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -567,7 +567,7 @@ impl<'a> SyntaxRewriter<'a> {
 fn element_to_green(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
    match element {
-        NodeOrToken::Node(it) => NodeOrToken::Node(it.green().to_owned()),
+        NodeOrToken::Node(it) => NodeOrToken::Node(it.green()),
        NodeOrToken::Token(it) => NodeOrToken::Token(it.green().to_owned()),
    }
 }
@@ -625,7 +625,7 @@ fn position_of_child(parent: &SyntaxNode, child: SyntaxElement) -> usize {
 fn to_green_element(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
    match element {
-        NodeOrToken::Node(it) => it.green().to_owned().into(),
+        NodeOrToken::Node(it) => it.green().into(),
        NodeOrToken::Token(it) => it.green().to_owned().into(),
    }
 }
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 64fac13a7..347862b8a 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -333,8 +333,7 @@ impl ast::Use {
            .and_then(ast::Whitespace::cast);
        if let Some(next_ws) = next_ws {
            let ws_text = next_ws.syntax().text();
-            if ws_text.starts_with('\n') {
+            if let Some(rest) = ws_text.strip_prefix('\n') {
-                let rest = &ws_text[1..];
                if rest.is_empty() {
                    res.delete(next_ws.syntax())
                } else {
@@ -462,8 +461,7 @@ impl ast::MatchArmList {
        let end = if let Some(comma) = start
            .siblings_with_tokens(Direction::Next)
            .skip(1)
-            .skip_while(|it| it.kind().is_trivia())
+            .find(|it| !it.kind().is_trivia())
-            .next()
            .filter(|it| it.kind() == T![,])
        {
            comma
@@ -597,7 +595,7 @@ impl IndentLevel {
    pub fn from_node(node: &SyntaxNode) -> IndentLevel {
        match node.first_token() {
            Some(it) => Self::from_token(&it),
-            None => return IndentLevel(0),
+            None => IndentLevel(0),
        }
    }
diff --git a/crates/syntax/src/ast/expr_ext.rs b/crates/syntax/src/ast/expr_ext.rs
index 636ce166d..6317d84ba 100644
--- a/crates/syntax/src/ast/expr_ext.rs
+++ b/crates/syntax/src/ast/expr_ext.rs
@@ -11,16 +11,16 @@ impl ast::AttrsOwner for ast::Expr {}
 impl ast::Expr {
    pub fn is_block_like(&self) -> bool {
-        match self {
+        matches!(
+            self,
            ast::Expr::IfExpr(_)
-            | ast::Expr::LoopExpr(_)
+                | ast::Expr::LoopExpr(_)
-            | ast::Expr::ForExpr(_)
+                | ast::Expr::ForExpr(_)
-            | ast::Expr::WhileExpr(_)
+                | ast::Expr::WhileExpr(_)
-            | ast::Expr::BlockExpr(_)
+                | ast::Expr::BlockExpr(_)
-            | ast::Expr::MatchExpr(_)
+                | ast::Expr::MatchExpr(_)
-            | ast::Expr::EffectExpr(_) => true,
+                | ast::Expr::EffectExpr(_)
-            _ => false,
+        )
-        }
    }
    pub fn name_ref(&self) -> Option<ast::NameRef> {
@@ -151,20 +151,20 @@ pub enum BinOp {
 impl BinOp {
    pub fn is_assignment(self) -> bool {
-        match self {
+        matches!(
+            self,
            BinOp::Assignment
-            | BinOp::AddAssign
+                | BinOp::AddAssign
-            | BinOp::DivAssign
+                | BinOp::DivAssign
-            | BinOp::MulAssign
+                | BinOp::MulAssign
-            | BinOp::RemAssign
+                | BinOp::RemAssign
-            | BinOp::ShrAssign
+                | BinOp::ShrAssign
-            | BinOp::ShlAssign
+                | BinOp::ShlAssign
-            | BinOp::SubAssign
+                | BinOp::SubAssign
-            | BinOp::BitOrAssign
+                | BinOp::BitOrAssign
-            | BinOp::BitAndAssign
+                | BinOp::BitAndAssign
-            | BinOp::BitXorAssign => true,
+                | BinOp::BitXorAssign
-            _ => false,
+        )
-        }
    }
 }
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 810c8d4c8..7049affd9 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -532,7 +532,7 @@ fn ast_from_text<N: AstNode>(text: &str) -> N {
 }
 fn unroot(n: SyntaxNode) -> SyntaxNode {
-    SyntaxNode::new_root(n.green().to_owned())
+    SyntaxNode::new_root(n.green())
 }
 pub mod tokens {
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index 42a7b9c2a..bdf907a21 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -58,10 +58,7 @@ impl From<ast::MacroDef> for Macro {
 impl AstNode for Macro {
    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
+        matches!(kind, SyntaxKind::MACRO_RULES | SyntaxKind::MACRO_DEF)
-            SyntaxKind::MACRO_RULES | SyntaxKind::MACRO_DEF => true,
-            _ => false,
-        }
    }
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        let res = match syntax.kind() {
@@ -462,10 +459,8 @@ impl ast::FieldExpr {
    pub fn field_access(&self) -> Option<FieldKind> {
        if let Some(nr) = self.name_ref() {
            Some(FieldKind::Name(nr))
-        } else if let Some(tok) = self.index_token() {
-            Some(FieldKind::Index(tok))
        } else {
-            None
+            self.index_token().map(FieldKind::Index)
        }
    }
 }
@@ -482,16 +477,10 @@ impl ast::SlicePat {
        let prefix = args
            .peeking_take_while(|p| match p {
                ast::Pat::RestPat(_) => false,
-                ast::Pat::IdentPat(bp) => match bp.pat() {
+                ast::Pat::IdentPat(bp) => !matches!(bp.pat(), Some(ast::Pat::RestPat(_))),
-                    Some(ast::Pat::RestPat(_)) => false,
-                    _ => true,
-                },
                ast::Pat::RefPat(rp) => match rp.pat() {
                    Some(ast::Pat::RestPat(_)) => false,
-                    Some(ast::Pat::IdentPat(bp)) => match bp.pat() {
+                    Some(ast::Pat::IdentPat(bp)) => !matches!(bp.pat(), Some(ast::Pat::RestPat(_))),
-                        Some(ast::Pat::RestPat(_)) => false,
-                        _ => true,
-                    },
                    _ => true,
                },
                _ => true,
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index 6c242d126..090282d28 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -494,9 +494,8 @@ pub trait HasFormatSpecifier: AstToken {
                }
                _ => {
                    while let Some((_, Ok(next_char))) = chars.peek() {
-                        match next_char {
+                        if next_char == &'{' {
-                            '{' => break,
+                            break;
-                            _ => {}
                        }
                        chars.next();
                    }
diff --git a/crates/syntax/src/fuzz.rs b/crates/syntax/src/fuzz.rs
index fbb97aa27..aa84239d2 100644
--- a/crates/syntax/src/fuzz.rs
+++ b/crates/syntax/src/fuzz.rs
@@ -43,7 +43,7 @@ impl CheckReparse {
            TextRange::at(delete_start.try_into().unwrap(), delete_len.try_into().unwrap());
        let edited_text =
            format!("{}{}{}", &text[..delete_start], &insert, &text[delete_start + delete_len..]);
-        let edit = Indel { delete, insert };
+        let edit = Indel { insert, delete };
        Some(CheckReparse { text, edit, edited_text })
    }
diff --git a/crates/syntax/src/validation.rs b/crates/syntax/src/validation.rs
index 3e216fb70..bbe802174 100644
--- a/crates/syntax/src/validation.rs
+++ b/crates/syntax/src/validation.rs
@@ -297,7 +297,7 @@ fn validate_path_keywords(segment: ast::PathSegment, errors: &mut Vec<SyntaxErro
                }
            };
        }
-        return None;
+        None
    }
    fn all_supers(path: &ast::Path) -> bool {
@@ -314,7 +314,7 @@ fn validate_path_keywords(segment: ast::PathSegment, errors: &mut Vec<SyntaxErro
            return all_supers(subpath);
        }
-        return true;
+        true
    }
 }
diff --git a/crates/tt/src/lib.rs b/crates/tt/src/lib.rs
index 9d9a01e30..bed44d600 100644
--- a/crates/tt/src/lib.rs
+++ b/crates/tt/src/lib.rs
@@ -239,9 +239,8 @@ impl Subtree {
        let mut res = String::new();
        res.push_str(delim.0);
-        let mut iter = self.token_trees.iter();
        let mut last = None;
-        while let Some(child) = iter.next() {
+        for child in &self.token_trees {
            let s = match child {
                TokenTree::Leaf(it) => {
                    let s = match it {