45 files changed, 1494 insertions, 404 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 9f013c275..19ee689cb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1324,9 +1324,9 @@ checksum = "b5eb417147ba9860a96cfe72a0b93bf88fee1744b5636ec99ab20c1aa9376581"
 [[package]]
 name = "rowan"
-version = "0.13.0-pre.2"
+version = "0.13.0-pre.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f300be7fa17c3fa563d2bc6ab5b1a8d5163162f9111599eda4f86a563714724"
+checksum = "77d315d6f2e33f294412faa47f41b56bdb3fce72c999d384b5e78c8d21551b13"
 dependencies = [
 "countme",
 "hashbrown",
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())
 }
diff --git a/docs/dev/README.md b/docs/dev/README.md
index b91013f13..57162a47d 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -226,6 +226,9 @@ If the GitHub Actions release fails because of a transient problem like a timeou
 If it fails because of something that needs to be fixed, remove the release tag (if needed), fix the problem, then start over.
 Make sure to remove the new changelog post created when running `cargo xtask release` a second time.
+We release "nightly" every night automatically and promote the latest nightly to "stable" manually, every week.
+We don't do "patch" releases, unless something truly egregious comes up.
 # Permissions
 There are three sets of people with extra permissions:
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index 694fafcd5..8a6f9f06e 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,5 +1,5 @@
 <!---
-lsp_ext.rs hash: 4dfa8d7035f4aee7
+lsp_ext.rs hash: e8a7502bd2b2c2f5
 If you need to change the above hash to make the test pass, please check if you
 need to adjust this doc as well and ping this  issue:
@@ -595,3 +595,29 @@ interface TestInfo {
    runnable: Runnable;
 }
 ```
+## Hover Actions
+**Issue:** https://github.com/rust-analyzer/rust-analyzer/issues/6823
+This request is sent from client to server to move item under cursor or selection in some direction.
+**Method:** `experimental/moveItemUp`
+**Method:** `experimental/moveItemDown`
+**Request:** `MoveItemParams`
+**Response:** `TextDocumentEdit | null`
+```typescript
+export interface MoveItemParams {
+    textDocument: lc.TextDocumentIdentifier,
+    range: lc.Range,
+    direction: Direction
+}
+export const enum Direction {
+    Up = "Up",
+    Down = "Down"
+}
+```
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index dba2197de..8656dd1da 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -516,6 +516,20 @@ See https://github.com/rust-analyzer/rust-project.json-example for a small examp
 You can set `RA_LOG` environmental variable to `rust_analyzer=info` to inspect how rust-analyzer handles config and project loading.
+== Security
+At the moment, rust-analyzer assumes that all code is trusted.
+Here is a **non-exhaustive** list of ways to make rust-analyzer execute arbitrary code:
+* proc macros and build scripts are executed by default
+* `.cargo/config` can override `rustc` with an arbitrary executable
+* VS Code plugin reads configuration from project directory, and that can be used to override paths to various executables, like `rustfmt` or `rust-analyzer` itself.
+* rust-analyzer's syntax trees library uses a lot of `unsafe` and hasn't been properly audited for memory safety.
+rust-analyzer itself doesn't access the network.
+The VS Code plugin doesn't access the network unless the nightly channel is selected in the settings.
+In that case, the plugin uses the GitHub API to check for and download updates.
 == Features
 include::./generated_features.adoc[]
diff --git a/editors/code/package.json b/editors/code/package.json
index a2ed9b2d5..faec45276 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -208,6 +208,16 @@
                "command": "rust-analyzer.peekTests",
                "title": "Peek related tests",
                "category": "Rust Analyzer"
+            },
+            {
+                "command": "rust-analyzer.moveItemUp",
+                "title": "Move item up",
+                "category": "Rust Analyzer"
+            },
+            {
+                "command": "rust-analyzer.moveItemDown",
+                "title": "Move item down",
+                "category": "Rust Analyzer"
            }
        ],
        "keybindings": [
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index bed1f0116..1a0805bd3 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -134,6 +134,51 @@ export function joinLines(ctx: Ctx): Cmd {
    };
 }
+export function moveItemUp(ctx: Ctx): Cmd {
+    return moveItem(ctx, ra.Direction.Up);
+}
+export function moveItemDown(ctx: Ctx): Cmd {
+    return moveItem(ctx, ra.Direction.Down);
+}
+export function moveItem(ctx: Ctx, direction: ra.Direction): Cmd {
+    return async () => {
+        const editor = ctx.activeRustEditor;
+        const client = ctx.client;
+        if (!editor || !client) return;
+        const edit = await client.sendRequest(ra.moveItem, {
+            range: client.code2ProtocolConverter.asRange(editor.selection),
+            textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
+            direction
+        });
+        if (!edit) return;
+        let cursor: vscode.Position | null = null;
+        await editor.edit((builder) => {
+            client.protocol2CodeConverter.asTextEdits(edit.edits).forEach((edit: any) => {
+                builder.replace(edit.range, edit.newText);
+                if (direction === ra.Direction.Up) {
+                    if (!cursor || edit.range.end.isBeforeOrEqual(cursor)) {
+                        cursor = edit.range.end;
+                    }
+                } else {
+                    if (!cursor || edit.range.end.isAfterOrEqual(cursor)) {
+                        cursor = edit.range.end;
+                    }
+                }
+            });
+        }).then(() => {
+            const newPosition = cursor ?? editor.selection.start;
+            editor.selection = new vscode.Selection(newPosition, newPosition);
+        });
+    };
+}
 export function onEnter(ctx: Ctx): Cmd {
    async function handleKeypress() {
        const editor = ctx.activeRustEditor;
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 52de29e04..00e128b8c 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -127,3 +127,16 @@ export const openCargoToml = new lc.RequestType<OpenCargoTomlParams, lc.Location
 export interface OpenCargoTomlParams {
    textDocument: lc.TextDocumentIdentifier;
 }
+export const moveItem = new lc.RequestType<MoveItemParams, lc.TextDocumentEdit | void, void>("experimental/moveItem");
+export interface MoveItemParams {
+    textDocument: lc.TextDocumentIdentifier;
+    range: lc.Range;
+    direction: Direction;
+}
+export const enum Direction {
+    Up = "Up",
+    Down = "Down"
+}
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 925103f56..643fb643f 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -114,6 +114,8 @@ async function tryActivate(context: vscode.ExtensionContext) {
    ctx.registerCommand('openDocs', commands.openDocs);
    ctx.registerCommand('openCargoToml', commands.openCargoToml);
    ctx.registerCommand('peekTests', commands.peekTests);
+    ctx.registerCommand('moveItemUp', commands.moveItemUp);
+    ctx.registerCommand('moveItemDown', commands.moveItemDown);
    defaultOnEnter.dispose();
    ctx.registerCommand('onEnter', commands.onEnter);