37 files changed, 1378 insertions, 401 deletions
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 e3ac37e4c..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;
@@ -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,11 +2054,11 @@ 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());
                        // skip the self type. it's likely the type we just got the bounds from
@@ -2079,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()));
@@ -2107,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/find_path.rs b/crates/hir_def/src/find_path.rs
index de08e2737..109d3552f 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -18,7 +18,8 @@ use crate::{
 /// *from where* you're referring to the item, hence the `from` parameter.
 pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
    let _p = profile::span("find_path");
-    find_path_inner(db, item, from, MAX_PATH_LEN, None)
+    let mut visited_modules = FxHashSet::default();
+    find_path_inner(db, item, from, MAX_PATH_LEN, None, &mut visited_modules)
 }
 pub fn find_path_prefixed(
@@ -28,7 +29,8 @@ pub fn find_path_prefixed(
    prefix_kind: PrefixKind,
 ) -> Option<ModPath> {
    let _p = profile::span("find_path_prefixed");
-    find_path_inner(db, item, from, MAX_PATH_LEN, Some(prefix_kind))
+    let mut visited_modules = FxHashSet::default();
+    find_path_inner(db, item, from, MAX_PATH_LEN, Some(prefix_kind), &mut visited_modules)
 }
 const MAX_PATH_LEN: usize = 15;
@@ -97,6 +99,7 @@ fn find_path_inner(
    from: ModuleId,
    max_len: usize,
    mut prefixed: Option<PrefixKind>,
+    visited_modules: &mut FxHashSet<ModuleId>,
 ) -> Option<ModPath> {
    if max_len == 0 {
        return None;
@@ -176,15 +179,18 @@ fn find_path_inner(
    if item.krate(db) == Some(from.krate) {
        // Item was defined in the same crate that wants to import it. It cannot be found in any
        // dependency in this case.
+        for (module_id, name) in find_local_import_locations(db, item, from) {
-        let local_imports = find_local_import_locations(db, item, from);
+            if !visited_modules.insert(module_id) {
-        for (module_id, name) in local_imports {
+                cov_mark::hit!(recursive_imports);
+                continue;
+            }
            if let Some(mut path) = find_path_inner(
                db,
                ItemInNs::Types(ModuleDefId::ModuleId(module_id)),
                from,
                best_path_len - 1,
                prefixed,
+                visited_modules,
            ) {
                path.push_segment(name);
@@ -213,6 +219,7 @@ fn find_path_inner(
                    from,
                    best_path_len - 1,
                    prefixed,
+                    visited_modules,
                )?;
                cov_mark::hit!(partially_imported);
                path.push_segment(info.path.segments.last().unwrap().clone());
@@ -391,8 +398,15 @@ mod tests {
            .take_types()
            .unwrap();
-        let found_path =
+        let mut visited_modules = FxHashSet::default();
-            find_path_inner(&db, ItemInNs::Types(resolved), module, MAX_PATH_LEN, prefix_kind);
+        let found_path = find_path_inner(
+            &db,
+            ItemInNs::Types(resolved),
+            module,
+            MAX_PATH_LEN,
+            prefix_kind,
+            &mut visited_modules,
+        );
        assert_eq!(found_path, Some(mod_path), "{:?}", prefix_kind);
    }
@@ -878,4 +892,32 @@ mod tests {
            "self::module::CompleteMe",
        )
    }
+    #[test]
+    fn recursive_pub_mod_reexport() {
+        cov_mark::check!(recursive_imports);
+        check_found_path(
+            r#"
+fn main() {
+    let _ = 22_i32.as_name$0();
+}
+pub mod name {
+    pub trait AsName {
+        fn as_name(&self) -> String;
+    }
+    impl AsName for i32 {
+        fn as_name(&self) -> String {
+            format!("Name: {}", self)
+        }
+    }
+    pub use crate::name;
+}
+"#,
+            "name::AsName",
+            "name::AsName",
+            "crate::name::AsName",
+            "self::name::AsName",
+        );
+    }
 }
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 0d3a0b54f..9e8e4e9ec 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -322,6 +322,23 @@ impl DefMap {
        (res.resolved_def, res.segment_index)
    }
+    pub(crate) fn resolve_path_locally(
+        &self,
+        db: &dyn DefDatabase,
+        original_module: LocalModuleId,
+        path: &ModPath,
+        shadow: BuiltinShadowMode,
+    ) -> (PerNs, Option<usize>) {
+        let res = self.resolve_path_fp_with_macro_single(
+            db,
+            ResolveMode::Other,
+            original_module,
+            path,
+            shadow,
+        );
+        (res.resolved_def, res.segment_index)
+    }
    /// Ascends the `DefMap` hierarchy and calls `f` with every `DefMap` and containing module.
    ///
    /// If `f` returns `Some(val)`, iteration is stopped and `Some(val)` is returned. If `f` returns
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index db459b1ed..60471937c 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -156,7 +156,7 @@ impl DefMap {
        }
    }
-    fn resolve_path_fp_with_macro_single(
+    pub(super) fn resolve_path_fp_with_macro_single(
        &self,
        db: &dyn DefDatabase,
        mode: ResolveMode,
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 04ea9c5d7..a73585ee7 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -548,7 +548,7 @@ impl ModuleItemMap {
        path: &ModPath,
    ) -> Option<ResolveValueResult> {
        let (module_def, idx) =
-            self.def_map.resolve_path(db, self.module_id, &path, BuiltinShadowMode::Other);
+            self.def_map.resolve_path_locally(db, self.module_id, &path, BuiltinShadowMode::Other);
        match idx {
            None => {
                let value = to_value_ns(module_def)?;
@@ -578,7 +578,7 @@ impl ModuleItemMap {
        path: &ModPath,
    ) -> Option<(TypeNs, Option<usize>)> {
        let (module_def, idx) =
-            self.def_map.resolve_path(db, self.module_id, &path, BuiltinShadowMode::Other);
+            self.def_map.resolve_path_locally(db, self.module_id, &path, BuiltinShadowMode::Other);
        let res = to_type_ns(module_def)?;
        Some((res, idx))
    }
@@ -627,8 +627,18 @@ pub trait HasResolver: Copy {
 impl HasResolver for ModuleId {
    fn resolver(self, db: &dyn DefDatabase) -> Resolver {
-        let def_map = self.def_map(db);
+        let mut def_map = self.def_map(db);
-        Resolver::default().push_module_scope(def_map, self.local_id)
+        let mut modules = Vec::new();
+        modules.push((def_map.clone(), self.local_id));
+        while let Some(parent) = def_map.parent() {
+            def_map = parent.def_map(db);
+            modules.push((def_map.clone(), parent.local_id));
+        }
+        let mut resolver = Resolver::default();
+        for (def_map, module) in modules.into_iter().rev() {
+            resolver = resolver.push_module_scope(def_map, module);
+        }
+        resolver
    }
 }
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 9d3b79be3..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> {
@@ -190,6 +190,7 @@ impl DisplayTarget {
 pub enum DisplaySourceCodeError {
    PathNotFound,
    UnknownType,
+    Closure,
 }
 pub enum HirDisplayError {
@@ -328,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,
@@ -345,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);
                    }
                }
@@ -539,6 +544,11 @@ impl HirDisplay for Ty {
                }
            }
            TyKind::Closure(.., substs) => {
+                if f.display_target.is_source_code() {
+                    return Err(HirDisplayError::DisplaySourceCodeError(
+                        DisplaySourceCodeError::Closure,
+                    ));
+                }
                let sig = substs[0].callable_sig(f.db);
                if let Some(sig) = sig {
                    if sig.params().is_empty() {
@@ -577,7 +587,7 @@ impl HirDisplay for Ty {
                            .generic_predicates(id.parent)
                            .into_iter()
                            .map(|pred| pred.clone().subst(&substs))
-                            .filter(|wc| match &wc {
+                            .filter(|wc| match &wc.skip_binders() {
                                WhereClause::Implemented(tr) => tr.self_type_parameter() == self,
                                WhereClause::AliasEq(AliasEq {
                                    alias: AliasTy::Projection(proj),
@@ -591,8 +601,12 @@ impl HirDisplay for Ty {
                }
            }
            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)) => {
@@ -661,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)?;
@@ -674,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.
@@ -687,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 24deff707..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| {
@@ -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/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 ad908f957..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)]
@@ -132,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)]
@@ -283,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
@@ -490,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 }
    }
@@ -501,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> {
@@ -614,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
@@ -623,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) }
    }
 }
@@ -810,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,
        }
    }
@@ -892,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()) {
@@ -905,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
@@ -945,7 +997,7 @@ impl Ty {
                            .generic_predicates(id.parent)
                            .into_iter()
                            .map(|pred| pred.clone().subst(&substs))
-                            .filter(|wc| match &wc {
+                            .filter(|wc| match &wc.skip_binders() {
                                WhereClause::Implemented(tr) => tr.self_type_parameter() == self,
                                WhereClause::AliasEq(AliasEq {
                                    alias: AliasTy::Projection(proj),
@@ -1094,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);
                }
            }
@@ -1122,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());
                }
            }
@@ -1173,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 fd451a823..3153b5b74 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,13 +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
+                    QuantifiedWhereClauses::from_iter(
-                        .iter()
+                        &Interner,
-                        .flat_map(|b| ctx.lower_type_bound(b, self_ty.clone(), false))
+                        bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone(), false)),
-                        .collect()
+                    )
                });
-                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 {
@@ -376,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);
            }
@@ -510,7 +521,7 @@ impl<'a> TyLoweringContext<'a> {
            TyDefId::AdtId(it) => Some(it.into()),
            TyDefId::TypeAliasId(it) => Some(it.into()),
        };
-        let substs = self.substs_from_path_segment(segment, generic_def, infer_args);
+        let substs = self.substs_from_path_segment(segment, generic_def, infer_args, None);
        self.db.ty(typeable).subst(&substs)
    }
@@ -547,7 +558,7 @@ impl<'a> TyLoweringContext<'a> {
                (segment, Some(var.parent.into()))
            }
        };
-        self.substs_from_path_segment(segment, generic_def, infer_args)
+        self.substs_from_path_segment(segment, generic_def, infer_args, None)
    }
    fn substs_from_path_segment(
@@ -555,6 +566,7 @@ impl<'a> TyLoweringContext<'a> {
        segment: PathSegment<'_>,
        def_generic: Option<GenericDefId>,
        infer_args: bool,
+        explicit_self_ty: Option<Ty>,
    ) -> Substitution {
        let mut substs = Vec::new();
        let def_generics = def_generic.map(|def| generics(self.db.upcast(), def));
@@ -565,11 +577,19 @@ impl<'a> TyLoweringContext<'a> {
        substs.extend(iter::repeat(TyKind::Unknown.intern(&Interner)).take(parent_params));
+        let fill_self_params = || {
+            substs.extend(
+                explicit_self_ty
+                    .into_iter()
+                    .chain(iter::repeat(TyKind::Unknown.intern(&Interner)))
+                    .take(self_params),
+            )
+        };
        let mut had_explicit_type_args = false;
        if let Some(generic_args) = &segment.args_and_bindings {
            if !generic_args.has_self_type {
-                substs.extend(iter::repeat(TyKind::Unknown.intern(&Interner)).take(self_params));
+                fill_self_params();
            }
            let expected_num =
                if generic_args.has_self_type { self_params + type_params } else { type_params };
@@ -591,6 +611,8 @@ impl<'a> TyLoweringContext<'a> {
                    GenericArg::Lifetime(_) => {}
                }
            }
+        } else {
+            fill_self_params();
        }
        // handle defaults. In expression or pattern path segments without
@@ -639,10 +661,7 @@ impl<'a> TyLoweringContext<'a> {
        segment: PathSegment<'_>,
        explicit_self_ty: Option<Ty>,
    ) -> TraitRef {
-        let mut substs = self.trait_ref_substs_from_path(segment, resolved);
+        let substs = self.trait_ref_substs_from_path(segment, resolved, explicit_self_ty);
-        if let Some(self_ty) = explicit_self_ty {
-            substs.0[0] = self_ty;
-        }
        TraitRef { trait_id: to_chalk_trait_id(resolved), substitution: substs }
    }
@@ -662,15 +681,16 @@ impl<'a> TyLoweringContext<'a> {
        &self,
        segment: PathSegment<'_>,
        resolved: TraitId,
+        explicit_self_ty: Option<Ty>,
    ) -> Substitution {
-        self.substs_from_path_segment(segment, Some(resolved.into()), false)
+        self.substs_from_path_segment(segment, Some(resolved.into()), false, explicit_self_ty)
    }
    pub(crate) fn lower_where_predicate(
        &'a self,
        where_predicate: &'a WherePredicate,
        ignore_bindings: bool,
-    ) -> impl Iterator<Item = WhereClause> + 'a {
+    ) -> impl Iterator<Item = QuantifiedWhereClause> + 'a {
        match where_predicate {
            WherePredicate::ForLifetime { target, bound, .. }
            | WherePredicate::TypeBound { target, bound } => {
@@ -705,12 +725,12 @@ impl<'a> TyLoweringContext<'a> {
        bound: &'a TypeBound,
        self_ty: Ty,
        ignore_bindings: bool,
-    ) -> impl Iterator<Item = WhereClause> + 'a {
+    ) -> 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,
@@ -727,7 +747,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,
@@ -743,7 +763,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 {
@@ -757,7 +777,7 @@ 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(
@@ -814,7 +834,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,
                })
@@ -887,7 +907,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);
@@ -915,7 +935,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([])
 }
@@ -930,7 +950,7 @@ pub(crate) fn trait_environment_query(
    let mut clauses = Vec::new();
    for pred in resolver.where_predicates_in_scope() {
        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> =
@@ -970,7 +990,7 @@ 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);
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/regression.rs b/crates/hir_ty/src/tests/regression.rs
index 69314e245..b69f86050 100644
--- a/crates/hir_ty/src/tests/regression.rs
+++ b/crates/hir_ty/src/tests/regression.rs
@@ -961,3 +961,16 @@ fn issue_6852() {
        "#]],
    );
 }
+#[test]
+fn param_overrides_fn() {
+    check_types(
+        r#"
+        fn example(example: i32) {
+            fn f() {}
+            example;
+          //^^^^^^^ i32
+        }
+        "#,
+    )
+}
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 37cd04c6f..45a1958e3 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -3324,3 +3324,49 @@ fn f() {
        "#]],
    )
 }
+#[test]
+fn infer_default_trait_type_parameter() {
+    check_infer(
+        r#"
+struct A;
+trait Op<RHS=Self> {
+    type Output;
+    fn do_op(self, rhs: RHS) -> Self::Output;
+}
+impl Op for A {
+    type Output = bool;
+    fn do_op(self, rhs: Self) -> Self::Output {
+        true
+    }
+}
+fn test() {
+    let x = A;
+    let y = A;
+    let r = x.do_op(y);
+}
+        "#,
+        expect![[r#"
+            63..67 'self': Self
+            69..72 'rhs': RHS
+            153..157 'self': A
+            159..162 'rhs': A
+            186..206 '{     ...     }': bool
+            196..200 'true': bool
+            220..277 '{     ...(y); }': ()
+            230..231 'x': A
+            234..235 'A': A
+            245..246 'y': A
+            249..250 'A': A
+            260..261 'r': bool
+            264..265 'x': A
+            264..274 'x.do_op(y)': bool
+            272..273 'y': A
+        "#]],
+    )
+}
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 944145603..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),
@@ -397,7 +400,6 @@ pub(crate) fn associated_ty_data_query(
        .iter()
        .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/lib.rs b/crates/ide/src/lib.rs
index 662da5a96..3f73c0632 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -37,6 +37,7 @@ mod hover;
 mod inlay_hints;
 mod join_lines;
 mod matching_brace;
+mod move_item;
 mod parent_module;
 mod references;
 mod fn_references;
@@ -76,6 +77,7 @@ pub use crate::{
    hover::{HoverAction, HoverConfig, HoverGotoTypeData, HoverResult},
    inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
    markup::Markup,
+    move_item::Direction,
    prime_caches::PrimeCachesProgress,
    references::{rename::RenameError, ReferenceSearchResult},
    runnables::{Runnable, RunnableKind, TestId},
@@ -583,6 +585,14 @@ impl Analysis {
        self.with_db(|db| annotations::resolve_annotation(db, annotation))
    }
+    pub fn move_item(
+        &self,
+        range: FileRange,
+        direction: Direction,
+    ) -> Cancelable<Option<TextEdit>> {
+        self.with_db(|db| move_item::move_item(db, range, direction))
+    }
    /// Performs an operation on that may be Canceled.
    fn with_db<F, T>(&self, f: F) -> Cancelable<T>
    where
diff --git a/crates/ide/src/move_item.rs b/crates/ide/src/move_item.rs
new file mode 100644
index 000000000..48690b073
--- /dev/null
+++ b/crates/ide/src/move_item.rs
@@ -0,0 +1,620 @@
+use std::iter::once;
+use hir::Semantics;
+use ide_db::{base_db::FileRange, RootDatabase};
+use itertools::Itertools;
+use syntax::{
+    algo, ast, match_ast, AstNode, NodeOrToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
+};
+use text_edit::{TextEdit, TextEditBuilder};
+pub enum Direction {
+    Up,
+    Down,
+}
+// Feature: Move Item
+//
+// Move item under cursor or selection up and down.
+//
+// |===
+// | Editor  | Action Name
+//
+// | VS Code | **Rust Analyzer: Move item up**
+// | VS Code | **Rust Analyzer: Move item down**
+// |===
+pub(crate) fn move_item(
+    db: &RootDatabase,
+    range: FileRange,
+    direction: Direction,
+) -> Option<TextEdit> {
+    let sema = Semantics::new(db);
+    let file = sema.parse(range.file_id);
+    let item = file.syntax().covering_element(range.range);
+    find_ancestors(item, direction, range.range)
+}
+fn find_ancestors(item: SyntaxElement, direction: Direction, range: TextRange) -> Option<TextEdit> {
+    let root = match item {
+        NodeOrToken::Node(node) => node,
+        NodeOrToken::Token(token) => token.parent()?,
+    };
+    let movable = [
+        SyntaxKind::ARG_LIST,
+        SyntaxKind::GENERIC_PARAM_LIST,
+        SyntaxKind::GENERIC_ARG_LIST,
+        SyntaxKind::VARIANT_LIST,
+        SyntaxKind::TYPE_BOUND_LIST,
+        SyntaxKind::MATCH_ARM,
+        SyntaxKind::PARAM,
+        SyntaxKind::LET_STMT,
+        SyntaxKind::EXPR_STMT,
+        SyntaxKind::MATCH_EXPR,
+        SyntaxKind::MACRO_CALL,
+        SyntaxKind::TYPE_ALIAS,
+        SyntaxKind::TRAIT,
+        SyntaxKind::IMPL,
+        SyntaxKind::MACRO_DEF,
+        SyntaxKind::STRUCT,
+        SyntaxKind::UNION,
+        SyntaxKind::ENUM,
+        SyntaxKind::FN,
+        SyntaxKind::MODULE,
+        SyntaxKind::USE,
+        SyntaxKind::STATIC,
+        SyntaxKind::CONST,
+        SyntaxKind::MACRO_RULES,
+    ];
+    let ancestor = once(root.clone())
+        .chain(root.ancestors())
+        .find(|ancestor| movable.contains(&ancestor.kind()))?;
+    move_in_direction(&ancestor, direction, range)
+}
+fn move_in_direction(
+    node: &SyntaxNode,
+    direction: Direction,
+    range: TextRange,
+) -> Option<TextEdit> {
+    match_ast! {
+        match node {
+            ast::ArgList(it) => swap_sibling_in_list(it.args(), range, direction),
+            ast::GenericParamList(it) => swap_sibling_in_list(it.generic_params(), range, direction),
+            ast::GenericArgList(it) => swap_sibling_in_list(it.generic_args(), range, direction),
+            ast::VariantList(it) => swap_sibling_in_list(it.variants(), range, direction),
+            ast::TypeBoundList(it) => swap_sibling_in_list(it.bounds(), range, direction),
+            _ => Some(replace_nodes(node, &match direction {
+                Direction::Up => node.prev_sibling(),
+                Direction::Down => node.next_sibling(),
+            }?))
+        }
+    }
+}
+fn swap_sibling_in_list<A: AstNode + Clone, I: Iterator<Item = A>>(
+    list: I,
+    range: TextRange,
+    direction: Direction,
+) -> Option<TextEdit> {
+    let (l, r) = list
+        .tuple_windows()
+        .filter(|(l, r)| match direction {
+            Direction::Up => r.syntax().text_range().contains_range(range),
+            Direction::Down => l.syntax().text_range().contains_range(range),
+        })
+        .next()?;
+    Some(replace_nodes(l.syntax(), r.syntax()))
+}
+fn replace_nodes(first: &SyntaxNode, second: &SyntaxNode) -> TextEdit {
+    let mut edit = TextEditBuilder::default();
+    algo::diff(first, second).into_text_edit(&mut edit);
+    algo::diff(second, first).into_text_edit(&mut edit);
+    edit.finish()
+}
+#[cfg(test)]
+mod tests {
+    use crate::fixture;
+    use expect_test::{expect, Expect};
+    use crate::Direction;
+    fn check(ra_fixture: &str, expect: Expect, direction: Direction) {
+        let (analysis, range) = fixture::range(ra_fixture);
+        let edit = analysis.move_item(range, direction).unwrap().unwrap_or_default();
+        let mut file = analysis.file_text(range.file_id).unwrap().to_string();
+        edit.apply(&mut file);
+        expect.assert_eq(&file);
+    }
+    #[test]
+    fn test_moves_match_arm_up() {
+        check(
+            r#"
+fn main() {
+    match true {
+        true => {
+            println!("Hello, world");
+        },
+        false =>$0$0 {
+            println!("Test");
+        }
+    };
+}
+            "#,
+            expect![[r#"
+fn main() {
+    match true {
+        false => {
+            println!("Test");
+        },
+        true => {
+            println!("Hello, world");
+        }
+    };
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_match_arm_down() {
+        check(
+            r#"
+fn main() {
+    match true {
+        true =>$0$0 {
+            println!("Hello, world");
+        },
+        false => {
+            println!("Test");
+        }
+    };
+}
+            "#,
+            expect![[r#"
+fn main() {
+    match true {
+        false => {
+            println!("Test");
+        },
+        true => {
+            println!("Hello, world");
+        }
+    };
+}
+            "#]],
+            Direction::Down,
+        );
+    }
+    #[test]
+    fn test_nowhere_to_move() {
+        check(
+            r#"
+fn main() {
+    match true {
+        true =>$0$0 {
+            println!("Hello, world");
+        },
+        false => {
+            println!("Test");
+        }
+    };
+}
+            "#,
+            expect![[r#"
+fn main() {
+    match true {
+        true => {
+            println!("Hello, world");
+        },
+        false => {
+            println!("Test");
+        }
+    };
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_let_stmt_up() {
+        check(
+            r#"
+fn main() {
+    let test = 123;
+    let test2$0$0 = 456;
+}
+            "#,
+            expect![[r#"
+fn main() {
+    let test2 = 456;
+    let test = 123;
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_expr_up() {
+        check(
+            r#"
+fn main() {
+    println!("Hello, world");
+    println!("All I want to say is...");$0$0
+}
+            "#,
+            expect![[r#"
+fn main() {
+    println!("All I want to say is...");
+    println!("Hello, world");
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_nowhere_to_move_stmt() {
+        check(
+            r#"
+fn main() {
+    println!("All I want to say is...");$0$0
+    println!("Hello, world");
+}
+            "#,
+            expect![[r#"
+fn main() {
+    println!("All I want to say is...");
+    println!("Hello, world");
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_move_item() {
+        check(
+            r#"
+fn main() {}
+fn foo() {}$0$0
+            "#,
+            expect![[r#"
+fn foo() {}
+fn main() {}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_move_impl_up() {
+        check(
+            r#"
+struct Yay;
+trait Wow {}
+impl Wow for Yay $0$0{}
+            "#,
+            expect![[r#"
+struct Yay;
+impl Wow for Yay {}
+trait Wow {}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_move_use_up() {
+        check(
+            r#"
+use std::vec::Vec;
+use std::collections::HashMap$0$0;
+            "#,
+            expect![[r#"
+use std::collections::HashMap;
+use std::vec::Vec;
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_match_expr_up() {
+        check(
+            r#"
+fn main() {
+    let test = 123;
+    $0match test {
+        456 => {},
+        _ => {}
+    };$0
+}
+            "#,
+            expect![[r#"
+fn main() {
+    match test {
+        456 => {},
+        _ => {}
+    };
+    let test = 123;
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_param_up() {
+        check(
+            r#"
+fn test(one: i32, two$0$0: u32) {}
+fn main() {
+    test(123, 456);
+}
+            "#,
+            expect![[r#"
+fn test(two: u32, one: i32) {}
+fn main() {
+    test(123, 456);
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_arg_up() {
+        check(
+            r#"
+fn test(one: i32, two: u32) {}
+fn main() {
+    test(123, 456$0$0);
+}
+            "#,
+            expect![[r#"
+fn test(one: i32, two: u32) {}
+fn main() {
+    test(456, 123);
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_arg_down() {
+        check(
+            r#"
+fn test(one: i32, two: u32) {}
+fn main() {
+    test(123$0$0, 456);
+}
+            "#,
+            expect![[r#"
+fn test(one: i32, two: u32) {}
+fn main() {
+    test(456, 123);
+}
+            "#]],
+            Direction::Down,
+        );
+    }
+    #[test]
+    fn test_nowhere_to_move_arg() {
+        check(
+            r#"
+fn test(one: i32, two: u32) {}
+fn main() {
+    test(123$0$0, 456);
+}
+            "#,
+            expect![[r#"
+fn test(one: i32, two: u32) {}
+fn main() {
+    test(123, 456);
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_generic_param_up() {
+        check(
+            r#"
+struct Test<A, B$0$0>(A, B);
+fn main() {}
+            "#,
+            expect![[r#"
+struct Test<B, A>(A, B);
+fn main() {}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_generic_arg_up() {
+        check(
+            r#"
+struct Test<A, B>(A, B);
+fn main() {
+    let t = Test::<i32, &str$0$0>(123, "yay");
+}
+            "#,
+            expect![[r#"
+struct Test<A, B>(A, B);
+fn main() {
+    let t = Test::<&str, i32>(123, "yay");
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_variant_up() {
+        check(
+            r#"
+enum Hello {
+    One,
+    Two$0$0
+}
+fn main() {}
+            "#,
+            expect![[r#"
+enum Hello {
+    Two,
+    One
+}
+fn main() {}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_moves_type_bound_up() {
+        check(
+            r#"
+trait One {}
+trait Two {}
+fn test<T: One + Two$0$0>(t: T) {}
+fn main() {}
+            "#,
+            expect![[r#"
+trait One {}
+trait Two {}
+fn test<T: Two + One>(t: T) {}
+fn main() {}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_prioritizes_trait_items() {
+        check(
+            r#"
+struct Test;
+trait Yay {
+    type One;
+    type Two;
+    fn inner();
+}
+impl Yay for Test {
+    type One = i32;
+    type Two = u32;
+    fn inner() {$0$0
+        println!("Mmmm");
+    }
+}
+            "#,
+            expect![[r#"
+struct Test;
+trait Yay {
+    type One;
+    type Two;
+    fn inner();
+}
+impl Yay for Test {
+    type One = i32;
+    fn inner() {
+        println!("Mmmm");
+    }
+    type Two = u32;
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn test_weird_nesting() {
+        check(
+            r#"
+fn test() {
+    mod hello {
+        fn inner() {}
+    }
+    mod hi {$0$0
+        fn inner() {}
+    }
+}
+            "#,
+            expect![[r#"
+fn test() {
+    mod hi {
+        fn inner() {}
+    }
+    mod hello {
+        fn inner() {}
+    }
+}
+            "#]],
+            Direction::Up,
+        );
+    }
+    #[test]
+    fn handles_empty_file() {
+        check(r#"$0$0"#, expect![[r#""#]], Direction::Up);
+    }
+}
diff --git a/crates/ide_assists/src/handlers/merge_imports.rs b/crates/ide_assists/src/handlers/merge_imports.rs
index 7bd7e1e36..cfc472a32 100644
--- a/crates/ide_assists/src/handlers/merge_imports.rs
+++ b/crates/ide_assists/src/handlers/merge_imports.rs
@@ -1,8 +1,5 @@
 use ide_db::helpers::insert_use::{try_merge_imports, try_merge_trees, MergeBehavior};
-use syntax::{
+use syntax::{algo::neighbor, ast, ted, AstNode};
-    algo::{neighbor, SyntaxRewriter},
-    ast, AstNode,
-};
 use crate::{
    assist_context::{AssistContext, Assists},
@@ -24,33 +21,29 @@ use crate::{
 // ```
 pub(crate) fn merge_imports(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let tree: ast::UseTree = ctx.find_node_at_offset()?;
-    let mut rewriter = SyntaxRewriter::default();
+    let original_parent = tree.syntax().ancestors().last()?;
+    let tree = tree.clone_for_update();
+    let new_parent = tree.syntax().ancestors().last()?;
    let mut offset = ctx.offset();
+    let mut imports = None;
+    let mut uses = None;
    if let Some(use_item) = tree.syntax().parent().and_then(ast::Use::cast) {
-        let (merged, to_delete) =
+        let (merged, to_remove) =
            next_prev().filter_map(|dir| neighbor(&use_item, dir)).find_map(|use_item2| {
                try_merge_imports(&use_item, &use_item2, MergeBehavior::Full).zip(Some(use_item2))
            })?;
-        rewriter.replace_ast(&use_item, &merged);
+        imports = Some((use_item, merged, to_remove));
-        rewriter += to_delete.remove();
-        if to_delete.syntax().text_range().end() < offset {
-            offset -= to_delete.syntax().text_range().len();
-        }
    } else {
-        let (merged, to_delete) =
+        let (merged, to_remove) =
            next_prev().filter_map(|dir| neighbor(&tree, dir)).find_map(|use_tree| {
                try_merge_trees(&tree, &use_tree, MergeBehavior::Full).zip(Some(use_tree))
            })?;
-        rewriter.replace_ast(&tree, &merged);
+        uses = Some((tree.clone(), merged, to_remove))
-        rewriter += to_delete.remove();
-        if to_delete.syntax().text_range().end() < offset {
-            offset -= to_delete.syntax().text_range().len();
-        }
    };
    let target = tree.syntax().text_range();
@@ -59,7 +52,23 @@ pub(crate) fn merge_imports(acc: &mut Assists, ctx: &AssistContext) -> Option<()
        "Merge imports",
        target,
        |builder| {
-            builder.rewrite(rewriter);
+            if let Some((to_replace, replacement, to_remove)) = imports {
+                if to_remove.syntax().text_range().end() < offset {
+                    offset -= to_remove.syntax().text_range().len();
+                }
+                ted::replace(to_replace.syntax().clone(), replacement.syntax().clone());
+                to_remove.remove();
+            }
+            if let Some((to_replace, replacement, to_remove)) = uses {
+                if to_remove.syntax().text_range().end() < offset {
+                    offset -= to_remove.syntax().text_range().len();
+                }
+                ted::replace(to_replace.syntax().clone(), replacement.syntax().clone());
+                to_remove.remove()
+            }
+            builder.replace(original_parent.text_range(), new_parent.to_string())
        },
    )
 }
diff --git a/crates/ide_assists/src/handlers/unmerge_use.rs b/crates/ide_assists/src/handlers/unmerge_use.rs
index 616af7c2e..8d271e056 100644
--- a/crates/ide_assists/src/handlers/unmerge_use.rs
+++ b/crates/ide_assists/src/handlers/unmerge_use.rs
@@ -1,6 +1,6 @@
 use syntax::{
-    algo::SyntaxRewriter,
+    ast::{self, VisibilityOwner},
-    ast::{self, edit::AstNodeEdit, VisibilityOwner},
+    ted::{self, Position},
    AstNode, SyntaxKind,
 };
@@ -22,7 +22,7 @@ use crate::{
 // use std::fmt::Display;
 // ```
 pub(crate) fn unmerge_use(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let tree: ast::UseTree = ctx.find_node_at_offset()?;
+    let tree: ast::UseTree = ctx.find_node_at_offset::<ast::UseTree>()?.clone_for_update();
    let tree_list = tree.syntax().parent().and_then(ast::UseTreeList::cast)?;
    if tree_list.use_trees().count() < 2 {
@@ -33,6 +33,9 @@ pub(crate) fn unmerge_use(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let use_: ast::Use = tree_list.syntax().ancestors().find_map(ast::Use::cast)?;
    let path = resolve_full_path(&tree)?;
+    let old_parent_range = use_.syntax().parent()?.text_range();
+    let new_parent = use_.syntax().parent()?;
    let target = tree.syntax().text_range();
    acc.add(
        AssistId("unmerge_use", AssistKind::RefactorRewrite),
@@ -47,20 +50,13 @@ pub(crate) fn unmerge_use(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
                    tree.rename(),
                    tree.star_token().is_some(),
                ),
-            );
+            )
+            .clone_for_update();
-            let mut rewriter = SyntaxRewriter::default();
-            rewriter += tree.remove();
+            tree.remove();
-            rewriter.insert_after(use_.syntax(), &ast::make::tokens::single_newline());
+            ted::insert(Position::after(use_.syntax()), new_use.syntax());
-            if let ident_level @ 1..=usize::MAX = use_.indent_level().0 as usize {
-                rewriter.insert_after(
+            builder.replace(old_parent_range, new_parent.to_string());
-                    use_.syntax(),
-                    &ast::make::tokens::whitespace(&" ".repeat(4 * ident_level)),
-                );
-            }
-            rewriter.insert_after(use_.syntax(), new_use.syntax());
-            builder.rewrite(rewriter);
        },
    )
 }
diff --git a/crates/ide_db/src/helpers/insert_use.rs b/crates/ide_db/src/helpers/insert_use.rs
index 9e0cb91c3..20c195f82 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,
 }
@@ -211,7 +213,7 @@ pub fn try_merge_imports(
    let lhs_tree = lhs.use_tree()?;
    let rhs_tree = rhs.use_tree()?;
    let merged = try_merge_trees(&lhs_tree, &rhs_tree, merge_behavior)?;
-    Some(lhs.with_use_tree(merged))
+    Some(lhs.with_use_tree(merged).clone_for_update())
 }
 pub fn try_merge_trees(
@@ -232,7 +234,7 @@ pub fn try_merge_trees(
    } else {
        (lhs.split_prefix(&lhs_prefix), rhs.split_prefix(&rhs_prefix))
    };
-    recursive_merge(&lhs, &rhs, merge)
+    recursive_merge(&lhs, &rhs, merge).map(|it| it.clone_for_update())
 }
 /// Recursively "zips" together lhs and rhs.
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/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 880fea622..85e67554c 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -1427,6 +1427,25 @@ pub(crate) fn handle_open_cargo_toml(
    Ok(Some(res))
 }
+pub(crate) fn handle_move_item(
+    snap: GlobalStateSnapshot,
+    params: lsp_ext::MoveItemParams,
+) -> Result<Option<lsp_types::TextDocumentEdit>> {
+    let _p = profile::span("handle_move_item");
+    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
+    let range = from_proto::file_range(&snap, params.text_document, params.range)?;
+    let direction = match params.direction {
+        lsp_ext::MoveItemDirection::Up => ide::Direction::Up,
+        lsp_ext::MoveItemDirection::Down => ide::Direction::Down,
+    };
+    match snap.analysis.move_item(range, direction)? {
+        Some(text_edit) => Ok(Some(to_proto::text_document_edit(&snap, file_id, text_edit)?)),
+        None => Ok(None),
+    }
+}
 fn to_command_link(command: lsp_types::Command, tooltip: String) -> lsp_ext::CommandLink {
    lsp_ext::CommandLink { tooltip: Some(tooltip), command }
 }
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index efcdcd1d9..0e1fec209 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -402,3 +402,25 @@ pub(crate) enum CodeLensResolveData {
 pub fn supports_utf8(caps: &lsp_types::ClientCapabilities) -> bool {
    caps.offset_encoding.as_deref().unwrap_or_default().iter().any(|it| it == "utf-8")
 }
+pub enum MoveItem {}
+impl Request for MoveItem {
+    type Params = MoveItemParams;
+    type Result = Option<lsp_types::TextDocumentEdit>;
+    const METHOD: &'static str = "experimental/moveItem";
+}
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct MoveItemParams {
+    pub direction: MoveItemDirection,
+    pub text_document: TextDocumentIdentifier,
+    pub range: Range,
+}
+#[derive(Serialize, Deserialize, Debug)]
+pub enum MoveItemDirection {
+    Up,
+    Down,
+}
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index c63a0eaea..e88f16cc1 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -504,6 +504,7 @@ impl GlobalState {
            .on::<lsp_ext::HoverRequest>(handlers::handle_hover)
            .on::<lsp_ext::ExternalDocs>(handlers::handle_open_docs)
            .on::<lsp_ext::OpenCargoToml>(handlers::handle_open_cargo_toml)
+            .on::<lsp_ext::MoveItem>(handlers::handle_move_item)
            .on::<lsp_types::request::OnTypeFormatting>(handlers::handle_on_type_formatting)
            .on::<lsp_types::request::DocumentSymbolRequest>(handlers::handle_document_symbol)
            .on::<lsp_types::request::WorkspaceSymbol>(handlers::handle_workspace_symbol)
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 1ddea9278..25169005f 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -658,6 +658,18 @@ pub(crate) fn goto_definition_response(
    }
 }
+pub(crate) fn text_document_edit(
+    snap: &GlobalStateSnapshot,
+    file_id: FileId,
+    edit: TextEdit,
+) -> Result<lsp_types::TextDocumentEdit> {
+    let text_document = optional_versioned_text_document_identifier(snap, file_id);
+    let line_index = snap.file_line_index(file_id)?;
+    let edits =
+        edit.into_iter().map(|it| lsp_types::OneOf::Left(text_edit(&line_index, it))).collect();
+    Ok(lsp_types::TextDocumentEdit { text_document, edits })
+}
 pub(crate) fn snippet_text_document_edit(
    snap: &GlobalStateSnapshot,
    is_snippet: bool,
@@ -1073,9 +1085,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/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index 74cafaa8d..0c3fec3c7 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 cov-mark = { version = "1.1", features = ["thread-local"] }
 itertools = "0.10.0"
-rowan = "0.13.0-pre.2"
+rowan = "0.13.0-pre.3"
 rustc_lexer = { version = "710.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 347862b8a..18820786a 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -9,7 +9,7 @@ use std::{
 use arrayvec::ArrayVec;
 use crate::{
-    algo::{self, neighbor, SyntaxRewriter},
+    algo::{self, SyntaxRewriter},
    ast::{
        self,
        make::{self, tokens},
@@ -322,27 +322,6 @@ impl ast::Use {
        }
        self.clone()
    }
-    pub fn remove(&self) -> SyntaxRewriter<'static> {
-        let mut res = SyntaxRewriter::default();
-        res.delete(self.syntax());
-        let next_ws = self
-            .syntax()
-            .next_sibling_or_token()
-            .and_then(|it| it.into_token())
-            .and_then(ast::Whitespace::cast);
-        if let Some(next_ws) = next_ws {
-            let ws_text = next_ws.syntax().text();
-            if let Some(rest) = ws_text.strip_prefix('\n') {
-                if rest.is_empty() {
-                    res.delete(next_ws.syntax())
-                } else {
-                    res.replace(next_ws.syntax(), &make::tokens::whitespace(rest));
-                }
-            }
-        }
-        res
-    }
 }
 impl ast::UseTree {
@@ -396,22 +375,6 @@ impl ast::UseTree {
            Some(res)
        }
    }
-    pub fn remove(&self) -> SyntaxRewriter<'static> {
-        let mut res = SyntaxRewriter::default();
-        res.delete(self.syntax());
-        for &dir in [Direction::Next, Direction::Prev].iter() {
-            if let Some(nb) = neighbor(self, dir) {
-                self.syntax()
-                    .siblings_with_tokens(dir)
-                    .skip(1)
-                    .take_while(|it| it.as_node() != Some(nb.syntax()))
-                    .for_each(|el| res.delete(&el));
-                return res;
-            }
-        }
-        res
-    }
 }
 impl ast::MatchArmList {
@@ -592,6 +555,13 @@ impl ops::Add<u8> for IndentLevel {
 }
 impl IndentLevel {
+    pub fn from_element(element: &SyntaxElement) -> IndentLevel {
+        match element {
+            rowan::NodeOrToken::Node(it) => IndentLevel::from_node(it),
+            rowan::NodeOrToken::Token(it) => IndentLevel::from_token(it),
+        }
+    }
    pub fn from_node(node: &SyntaxNode) -> IndentLevel {
        match node.first_token() {
            Some(it) => Self::from_token(&it),
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index b1eed0a2c..529bd0eb1 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -2,13 +2,13 @@
 use std::iter::empty;
-use ast::{edit::AstNodeEdit, make, GenericParamsOwner, WhereClause};
 use parser::T;
 use crate::{
-    ast,
+    algo::neighbor,
+    ast::{self, edit::AstNodeEdit, make, GenericParamsOwner, WhereClause},
    ted::{self, Position},
-    AstNode, Direction,
+    AstNode, AstToken, Direction,
 };
 use super::NameOwner;
@@ -126,3 +126,41 @@ impl ast::TypeBoundList {
        }
    }
 }
+impl ast::UseTree {
+    pub fn remove(&self) {
+        for &dir in [Direction::Next, Direction::Prev].iter() {
+            if let Some(next_use_tree) = neighbor(self, dir) {
+                let separators = self
+                    .syntax()
+                    .siblings_with_tokens(dir)
+                    .skip(1)
+                    .take_while(|it| it.as_node() != Some(next_use_tree.syntax()));
+                ted::remove_all_iter(separators);
+                break;
+            }
+        }
+        ted::remove(self.syntax())
+    }
+}
+impl ast::Use {
+    pub fn remove(&self) {
+        let next_ws = self
+            .syntax()
+            .next_sibling_or_token()
+            .and_then(|it| it.into_token())
+            .and_then(ast::Whitespace::cast);
+        if let Some(next_ws) = next_ws {
+            let ws_text = next_ws.syntax().text();
+            if let Some(rest) = ws_text.strip_prefix('\n') {
+                if rest.is_empty() {
+                    ted::remove(next_ws.syntax())
+                } else {
+                    ted::replace(next_ws.syntax(), make::tokens::whitespace(rest))
+                }
+            }
+        }
+        ted::remove(self.syntax())
+    }
+}
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 7049affd9..c08f2c14f 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -560,7 +560,7 @@ pub mod tokens {
    pub fn whitespace(text: &str) -> SyntaxToken {
        assert!(text.trim().is_empty());
        let sf = SourceFile::parse(text).ok().unwrap();
-        sf.syntax().first_child_or_token().unwrap().into_token().unwrap()
+        sf.syntax().clone_for_update().first_child_or_token().unwrap().into_token().unwrap()
    }
    pub fn doc_comment(text: &str) -> SyntaxToken {
diff --git a/crates/syntax/src/ted.rs b/crates/syntax/src/ted.rs
index be2b846b1..177d4ff67 100644
--- a/crates/syntax/src/ted.rs
+++ b/crates/syntax/src/ted.rs
@@ -2,11 +2,14 @@
 //!
 //! The `_raw`-suffixed functions insert elements as is, unsuffixed versions fix
 //! up elements around the edges.
-use std::ops::RangeInclusive;
+use std::{mem, ops::RangeInclusive};
 use parser::T;
-use crate::{ast::make, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken};
+use crate::{
+    ast::{edit::IndentLevel, make},
+    SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken,
+};
 /// Utility trait to allow calling `ted` functions with references or owned
 /// nodes. Do not use outside of this module.
@@ -101,12 +104,25 @@ pub fn insert_all_raw(position: Position, elements: Vec<SyntaxElement>) {
 }
 pub fn remove(elem: impl Element) {
-    let elem = elem.syntax_element();
+    elem.syntax_element().detach()
-    remove_all(elem.clone()..=elem)
 }
 pub fn remove_all(range: RangeInclusive<SyntaxElement>) {
    replace_all(range, Vec::new())
 }
+pub fn remove_all_iter(range: impl IntoIterator<Item = SyntaxElement>) {
+    let mut it = range.into_iter();
+    if let Some(mut first) = it.next() {
+        match it.last() {
+            Some(mut last) => {
+                if first.index() > last.index() {
+                    mem::swap(&mut first, &mut last)
+                }
+                remove_all(first..=last)
+            }
+            None => remove(first),
+        }
+    }
+}
 pub fn replace(old: impl Element, new: impl Element) {
    let old = old.syntax_element();
@@ -149,5 +165,9 @@ fn ws_between(left: &SyntaxElement, right: &SyntaxElement) -> Option<SyntaxToken
    if right.kind() == T![;] || right.kind() == T![,] {
        return None;
    }
+    if right.kind() == SyntaxKind::USE {
+        let indent = IndentLevel::from_element(left);
+        return Some(make::tokens::whitespace(&format!("\n{}", indent)));
+    }
    Some(make::tokens::single_space())
 }