87 files changed, 2070 insertions, 843 deletions
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 5c9824814..cad6866aa 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -57,7 +57,7 @@
 //! fn insert_source_code_here() {}
 //! "
 //! ```
-use std::{str::FromStr, sync::Arc};
+use std::{mem, str::FromStr, sync::Arc};
 use cfg::CfgOptions;
 use rustc_hash::FxHashMap;
@@ -148,6 +148,7 @@ impl ChangeFixture {
        let mut file_set = FileSet::default();
        let source_root_prefix = "/".to_string();
        let mut file_id = FileId(0);
+        let mut roots = Vec::new();
        let mut file_position = None;
@@ -168,6 +169,10 @@ impl ChangeFixture {
            let meta = FileMeta::from(entry);
            assert!(meta.path.starts_with(&source_root_prefix));
+            if meta.introduce_new_source_root {
+                roots.push(SourceRoot::new_local(mem::take(&mut file_set)));
+            }
            if let Some(krate) = meta.krate {
                let crate_name = CrateName::normalize_dashes(&krate);
                let crate_id = crate_graph.add_crate_root(
@@ -215,7 +220,8 @@ impl ChangeFixture {
            }
        }
-        change.set_roots(vec![SourceRoot::new_local(file_set)]);
+        roots.push(SourceRoot::new_local(mem::take(&mut file_set)));
+        change.set_roots(roots);
        change.set_crate_graph(crate_graph);
        ChangeFixture { file_position, files, change }
@@ -229,6 +235,7 @@ struct FileMeta {
    cfg: CfgOptions,
    edition: Edition,
    env: Env,
+    introduce_new_source_root: bool,
 }
 impl From<Fixture> for FileMeta {
@@ -247,6 +254,7 @@ impl From<Fixture> for FileMeta {
                .as_ref()
                .map_or(Edition::Edition2018, |v| Edition::from_str(&v).unwrap()),
            env: f.env.into_iter().collect(),
+            introduce_new_source_root: f.introduce_new_source_root,
        }
    }
 }
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index b5f7e4200..d0def2181 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -274,6 +274,33 @@ impl CrateGraph {
        deps.into_iter()
    }
+    /// Returns an iterator over all transitive reverse dependencies of the given crate.
+    pub fn transitive_reverse_dependencies(
+        &self,
+        of: CrateId,
+    ) -> impl Iterator<Item = CrateId> + '_ {
+        let mut worklist = vec![of];
+        let mut rev_deps = FxHashSet::default();
+        let mut inverted_graph = FxHashMap::<_, Vec<_>>::default();
+        self.arena.iter().for_each(|(&krate, data)| {
+            data.dependencies
+                .iter()
+                .for_each(|dep| inverted_graph.entry(dep.crate_id).or_default().push(krate))
+        });
+        while let Some(krate) = worklist.pop() {
+            if let Some(krate_rev_deps) = inverted_graph.get(&krate) {
+                krate_rev_deps
+                    .iter()
+                    .copied()
+                    .filter(|&rev_dep| rev_deps.insert(rev_dep))
+                    .for_each(|rev_dep| worklist.push(rev_dep));
+            }
+        }
+        rev_deps.into_iter()
+    }
    /// Returns all crates in the graph, sorted in topological order (ie. dependencies of a crate
    /// come before the crate itself).
    pub fn crates_in_topological_order(&self) -> Vec<CrateId> {
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs
new file mode 100644
index 000000000..9f6d7be48
--- /dev/null
+++ b/crates/hir/src/display.rs
@@ -0,0 +1,467 @@
+//! HirDisplay implementations for various hir types.
+use hir_def::{
+    adt::VariantData,
+    generics::{TypeParamProvenance, WherePredicate, WherePredicateTypeTarget},
+    type_ref::{TypeBound, TypeRef},
+    AdtId, GenericDefId,
+};
+use hir_ty::display::{
+    write_bounds_like_dyn_trait_with_prefix, write_visibility, HirDisplay, HirDisplayError,
+    HirFormatter,
+};
+use syntax::ast::{self, NameOwner};
+use crate::{
+    Adt, Const, ConstParam, Enum, Field, Function, GenericParam, HasVisibility, LifetimeParam,
+    Module, Static, Struct, Substitution, Trait, Type, TypeAlias, TypeParam, Union, Variant,
+};
+impl HirDisplay for Function {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        let data = f.db.function_data(self.id);
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        let qual = &data.qualifier;
+        if qual.is_default {
+            write!(f, "default ")?;
+        }
+        if qual.is_const {
+            write!(f, "const ")?;
+        }
+        if qual.is_async {
+            write!(f, "async ")?;
+        }
+        if qual.is_unsafe {
+            write!(f, "unsafe ")?;
+        }
+        if let Some(abi) = &qual.abi {
+            // FIXME: String escape?
+            write!(f, "extern \"{}\" ", abi)?;
+        }
+        write!(f, "fn {}", data.name)?;
+        write_generic_params(GenericDefId::FunctionId(self.id), f)?;
+        write!(f, "(")?;
+        let write_self_param = |ty: &TypeRef, f: &mut HirFormatter| match ty {
+            TypeRef::Path(p) if p.is_self_type() => write!(f, "self"),
+            TypeRef::Reference(inner, lifetime, mut_) if matches!(&**inner,TypeRef::Path(p) if p.is_self_type()) =>
+            {
+                write!(f, "&")?;
+                if let Some(lifetime) = lifetime {
+                    write!(f, "{} ", lifetime.name)?;
+                }
+                if let hir_def::type_ref::Mutability::Mut = mut_ {
+                    write!(f, "mut ")?;
+                }
+                write!(f, "self")
+            }
+            _ => {
+                write!(f, "self: ")?;
+                ty.hir_fmt(f)
+            }
+        };
+        let mut first = true;
+        for (param, type_ref) in self.assoc_fn_params(f.db).into_iter().zip(&data.params) {
+            if !first {
+                write!(f, ", ")?;
+            } else {
+                first = false;
+                if data.has_self_param {
+                    write_self_param(type_ref, f)?;
+                    continue;
+                }
+            }
+            match param.pattern_source(f.db) {
+                Some(ast::Pat::IdentPat(p)) if p.name().is_some() => {
+                    write!(f, "{}: ", p.name().unwrap())?
+                }
+                _ => write!(f, "_: ")?,
+            }
+            // FIXME: Use resolved `param.ty` or raw `type_ref`?
+            // The former will ignore lifetime arguments currently.
+            type_ref.hir_fmt(f)?;
+        }
+        write!(f, ")")?;
+        // `FunctionData::ret_type` will be `::core::future::Future<Output = ...>` for async fns.
+        // Use ugly pattern match to strip the Future trait.
+        // Better way?
+        let ret_type = if !qual.is_async {
+            &data.ret_type
+        } else {
+            match &data.ret_type {
+                TypeRef::ImplTrait(bounds) => match &bounds[0] {
+                    TypeBound::Path(path) => {
+                        path.segments().iter().last().unwrap().args_and_bindings.unwrap().bindings
+                            [0]
+                        .type_ref
+                        .as_ref()
+                        .unwrap()
+                    }
+                    _ => panic!("Async fn ret_type should be impl Future"),
+                },
+                _ => panic!("Async fn ret_type should be impl Future"),
+            }
+        };
+        match ret_type {
+            TypeRef::Tuple(tup) if tup.is_empty() => {}
+            ty => {
+                write!(f, " -> ")?;
+                ty.hir_fmt(f)?;
+            }
+        }
+        write_where_clause(GenericDefId::FunctionId(self.id), f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Adt {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        match self {
+            Adt::Struct(it) => it.hir_fmt(f),
+            Adt::Union(it) => it.hir_fmt(f),
+            Adt::Enum(it) => it.hir_fmt(f),
+        }
+    }
+}
+impl HirDisplay for Struct {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        write!(f, "struct ")?;
+        write!(f, "{}", self.name(f.db))?;
+        let def_id = GenericDefId::AdtId(AdtId::StructId(self.id));
+        write_generic_params(def_id, f)?;
+        write_where_clause(def_id, f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Enum {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        write!(f, "enum ")?;
+        write!(f, "{}", self.name(f.db))?;
+        let def_id = GenericDefId::AdtId(AdtId::EnumId(self.id));
+        write_generic_params(def_id, f)?;
+        write_where_clause(def_id, f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Union {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        write!(f, "union ")?;
+        write!(f, "{}", self.name(f.db))?;
+        let def_id = GenericDefId::AdtId(AdtId::UnionId(self.id));
+        write_generic_params(def_id, f)?;
+        write_where_clause(def_id, f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Field {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.parent.module(f.db).id, self.visibility(f.db), f)?;
+        write!(f, "{}: ", self.name(f.db))?;
+        self.signature_ty(f.db).hir_fmt(f)
+    }
+}
+impl HirDisplay for Variant {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write!(f, "{}", self.name(f.db))?;
+        let data = self.variant_data(f.db);
+        match &*data {
+            VariantData::Unit => {}
+            VariantData::Tuple(fields) => {
+                write!(f, "(")?;
+                let mut first = true;
+                for (_, field) in fields.iter() {
+                    if first {
+                        first = false;
+                    } else {
+                        write!(f, ", ")?;
+                    }
+                    // Enum variant fields must be pub.
+                    field.type_ref.hir_fmt(f)?;
+                }
+                write!(f, ")")?;
+            }
+            VariantData::Record(fields) => {
+                write!(f, " {{")?;
+                let mut first = true;
+                for (_, field) in fields.iter() {
+                    if first {
+                        first = false;
+                        write!(f, " ")?;
+                    } else {
+                        write!(f, ", ")?;
+                    }
+                    // Enum variant fields must be pub.
+                    write!(f, "{}: ", field.name)?;
+                    field.type_ref.hir_fmt(f)?;
+                }
+                write!(f, " }}")?;
+            }
+        }
+        Ok(())
+    }
+}
+impl HirDisplay for Type {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        self.ty.value.hir_fmt(f)
+    }
+}
+impl HirDisplay for GenericParam {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        match self {
+            GenericParam::TypeParam(it) => it.hir_fmt(f),
+            GenericParam::LifetimeParam(it) => it.hir_fmt(f),
+            GenericParam::ConstParam(it) => it.hir_fmt(f),
+        }
+    }
+}
+impl HirDisplay for TypeParam {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write!(f, "{}", self.name(f.db))?;
+        let bounds = f.db.generic_predicates_for_param(self.id);
+        let substs = Substitution::type_params(f.db, self.id.parent);
+        let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>();
+        if !(predicates.is_empty() || f.omit_verbose_types()) {
+            write_bounds_like_dyn_trait_with_prefix(":", &predicates, f)?;
+        }
+        Ok(())
+    }
+}
+impl HirDisplay for LifetimeParam {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write!(f, "{}", self.name(f.db))
+    }
+}
+impl HirDisplay for ConstParam {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write!(f, "const {}: ", self.name(f.db))?;
+        self.ty(f.db).hir_fmt(f)
+    }
+}
+fn write_generic_params(def: GenericDefId, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+    let params = f.db.generic_params(def);
+    if params.lifetimes.is_empty()
+        && params.consts.is_empty()
+        && params
+            .types
+            .iter()
+            .all(|(_, param)| !matches!(param.provenance, TypeParamProvenance::TypeParamList))
+    {
+        return Ok(());
+    }
+    write!(f, "<")?;
+    let mut first = true;
+    let mut delim = |f: &mut HirFormatter| {
+        if first {
+            first = false;
+            Ok(())
+        } else {
+            write!(f, ", ")
+        }
+    };
+    for (_, lifetime) in params.lifetimes.iter() {
+        delim(f)?;
+        write!(f, "{}", lifetime.name)?;
+    }
+    for (_, ty) in params.types.iter() {
+        if ty.provenance != TypeParamProvenance::TypeParamList {
+            continue;
+        }
+        if let Some(name) = &ty.name {
+            delim(f)?;
+            write!(f, "{}", name)?;
+            if let Some(default) = &ty.default {
+                write!(f, " = ")?;
+                default.hir_fmt(f)?;
+            }
+        }
+    }
+    for (_, konst) in params.consts.iter() {
+        delim(f)?;
+        write!(f, "const {}: ", konst.name)?;
+        konst.ty.hir_fmt(f)?;
+    }
+    write!(f, ">")?;
+    Ok(())
+}
+fn write_where_clause(def: GenericDefId, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+    let params = f.db.generic_params(def);
+    if params.where_predicates.is_empty() {
+        return Ok(());
+    }
+    let write_target = |target: &WherePredicateTypeTarget, f: &mut HirFormatter| match target {
+        WherePredicateTypeTarget::TypeRef(ty) => ty.hir_fmt(f),
+        WherePredicateTypeTarget::TypeParam(id) => match &params.types[*id].name {
+            Some(name) => write!(f, "{}", name),
+            None => write!(f, "{{unnamed}}"),
+        },
+    };
+    write!(f, "\nwhere")?;
+    for (pred_idx, pred) in params.where_predicates.iter().enumerate() {
+        let prev_pred =
+            if pred_idx == 0 { None } else { Some(&params.where_predicates[pred_idx - 1]) };
+        let new_predicate = |f: &mut HirFormatter| {
+            write!(f, "{}", if pred_idx == 0 { "\n    " } else { ",\n    " })
+        };
+        match pred {
+            WherePredicate::TypeBound { target, bound } => {
+                if matches!(prev_pred, Some(WherePredicate::TypeBound { target: target_, .. }) if target_ == target)
+                {
+                    write!(f, " + ")?;
+                } else {
+                    new_predicate(f)?;
+                    write_target(target, f)?;
+                    write!(f, ": ")?;
+                }
+                bound.hir_fmt(f)?;
+            }
+            WherePredicate::Lifetime { target, bound } => {
+                if matches!(prev_pred, Some(WherePredicate::Lifetime { target: target_, .. }) if target_ == target)
+                {
+                    write!(f, " + {}", bound.name)?;
+                } else {
+                    new_predicate(f)?;
+                    write!(f, "{}: {}", target.name, bound.name)?;
+                }
+            }
+            WherePredicate::ForLifetime { lifetimes, target, bound } => {
+                if matches!(
+                    prev_pred,
+                    Some(WherePredicate::ForLifetime { lifetimes: lifetimes_, target: target_, .. })
+                    if lifetimes_ == lifetimes && target_ == target,
+                ) {
+                    write!(f, " + ")?;
+                } else {
+                    new_predicate(f)?;
+                    write!(f, "for<")?;
+                    for (idx, lifetime) in lifetimes.iter().enumerate() {
+                        if idx != 0 {
+                            write!(f, ", ")?;
+                        }
+                        write!(f, "{}", lifetime)?;
+                    }
+                    write!(f, "> ")?;
+                    write_target(target, f)?;
+                    write!(f, ": ")?;
+                }
+                bound.hir_fmt(f)?;
+            }
+        }
+    }
+    // End of final predicate. There must be at least one predicate here.
+    write!(f, ",")?;
+    Ok(())
+}
+impl HirDisplay for Const {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        let data = f.db.const_data(self.id);
+        write!(f, "const ")?;
+        match &data.name {
+            Some(name) => write!(f, "{}: ", name)?,
+            None => write!(f, "_: ")?,
+        }
+        data.type_ref.hir_fmt(f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Static {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        let data = f.db.static_data(self.id);
+        write!(f, "static ")?;
+        if data.mutable {
+            write!(f, "mut ")?;
+        }
+        match &data.name {
+            Some(name) => write!(f, "{}: ", name)?,
+            None => write!(f, "_: ")?,
+        }
+        data.type_ref.hir_fmt(f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Trait {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        let data = f.db.trait_data(self.id);
+        if data.is_unsafe {
+            write!(f, "unsafe ")?;
+        }
+        if data.is_auto {
+            write!(f, "auto ")?;
+        }
+        write!(f, "trait {}", data.name)?;
+        let def_id = GenericDefId::TraitId(self.id);
+        write_generic_params(def_id, f)?;
+        if !data.bounds.is_empty() {
+            write!(f, ": ")?;
+            f.write_joined(&*data.bounds, " + ")?;
+        }
+        write_where_clause(def_id, f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for TypeAlias {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        let data = f.db.type_alias_data(self.id);
+        write!(f, "type {}", data.name)?;
+        if !data.bounds.is_empty() {
+            write!(f, ": ")?;
+            f.write_joined(&data.bounds, " + ")?;
+        }
+        if let Some(ty) = &data.type_ref {
+            write!(f, " = ")?;
+            ty.hir_fmt(f)?;
+        }
+        Ok(())
+    }
+}
+impl HirDisplay for Module {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        // FIXME: Module doesn't have visibility saved in data.
+        match self.name(f.db) {
+            Some(name) => write!(f, "mod {}", name),
+            None if self.crate_root(f.db) == *self => match self.krate().display_name(f.db) {
+                Some(name) => write!(f, "extern crate {}", name),
+                None => write!(f, "extern crate {{unknown}}"),
+            },
+            None => write!(f, "mod {{unnamed}}"),
+        }
+    }
+}
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index c5161dadd..12dd5fb38 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -29,6 +29,8 @@ mod has_source;
 pub mod diagnostics;
 pub mod db;
+mod display;
 use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
@@ -50,14 +52,15 @@ use hir_def::{
 use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind};
 use hir_ty::{
    autoderef,
-    display::{write_bounds_like_dyn_trait_with_prefix, HirDisplayError, HirFormatter},
    method_resolution::{self, TyFingerprint},
+    primitive::UintTy,
    to_assoc_type_id,
    traits::{FnTrait, Solution, SolutionVariables},
    AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate,
-    InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substs, Ty,
+    InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substitution,
-    TyDefId, TyKind, TyVariableKind,
+    Ty, TyDefId, TyKind, TyVariableKind,
 };
+use itertools::Itertools;
 use rustc_hash::FxHashSet;
 use stdx::{format_to, impl_from};
 use syntax::{
@@ -139,7 +142,6 @@ impl Crate {
            .collect()
    }
-    // FIXME: add `transitive_reverse_dependencies`.
    pub fn reverse_dependencies(self, db: &dyn HirDatabase) -> Vec<Crate> {
        let crate_graph = db.crate_graph();
        crate_graph
@@ -151,6 +153,14 @@ impl Crate {
            .collect()
    }
+    pub fn transitive_reverse_dependencies(self, db: &dyn HirDatabase) -> Vec<Crate> {
+        db.crate_graph()
+            .transitive_reverse_dependencies(self.id)
+            .into_iter()
+            .map(|id| Crate { id })
+            .collect()
+    }
    pub fn root_module(self, db: &dyn HirDatabase) -> Module {
        let def_map = db.crate_def_map(self.id);
        Module { id: def_map.module_id(def_map.root()) }
@@ -508,7 +518,7 @@ impl Field {
            VariantDef::Union(it) => it.id.into(),
            VariantDef::Variant(it) => it.parent.id.into(),
        };
-        let substs = Substs::type_params(db, generic_def_id);
+        let substs = Substitution::type_params(db, generic_def_id);
        let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
        Type::new(db, self.parent.module(db).id.krate(), var_id, ty)
    }
@@ -571,6 +581,12 @@ impl Struct {
    }
 }
+impl HasVisibility for Struct {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        db.struct_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Union {
    pub(crate) id: UnionId,
@@ -603,6 +619,12 @@ impl Union {
    }
 }
+impl HasVisibility for Union {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        db.union_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Enum {
    pub(crate) id: EnumId,
@@ -630,6 +652,12 @@ impl Enum {
    }
 }
+impl HasVisibility for Enum {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        db.enum_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Variant {
    pub(crate) parent: Enum,
@@ -821,7 +849,8 @@ impl Function {
        db.function_data(self.id)
            .params
            .iter()
-            .map(|type_ref| {
+            .enumerate()
+            .map(|(idx, type_ref)| {
                let ty = Type {
                    krate,
                    ty: InEnvironment {
@@ -829,7 +858,7 @@ impl Function {
                        environment: environment.clone(),
                    },
                };
-                Param { ty }
+                Param { func: self, ty, idx }
            })
            .collect()
    }
@@ -843,7 +872,7 @@ impl Function {
    }
    pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool {
-        db.function_data(self.id).is_unsafe
+        db.function_data(self.id).qualifier.is_unsafe
    }
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
@@ -892,6 +921,9 @@ impl From<hir_ty::Mutability> for Access {
 #[derive(Debug)]
 pub struct Param {
+    func: Function,
+    /// The index in parameter list, including self parameter.
+    idx: usize,
    ty: Type,
 }
@@ -899,6 +931,15 @@ impl Param {
    pub fn ty(&self) -> &Type {
        &self.ty
    }
+    pub fn pattern_source(&self, db: &dyn HirDatabase) -> Option<ast::Pat> {
+        let params = self.func.source(db)?.value.param_list()?;
+        if params.self_param().is_some() {
+            params.params().nth(self.idx.checked_sub(1)?)?.pat()
+        } else {
+            params.params().nth(self.idx)?.pat()
+        }
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -921,6 +962,14 @@ impl SelfParam {
            })
            .unwrap_or(Access::Owned)
    }
+    pub fn display(self, db: &dyn HirDatabase) -> &'static str {
+        match self.access(db) {
+            Access::Shared => "&self",
+            Access::Exclusive => "&mut self",
+            Access::Owned => "self",
+        }
+    }
 }
 impl HasVisibility for Function {
@@ -948,6 +997,10 @@ impl Const {
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
        db.const_data(self.id).name.clone()
    }
+    pub fn type_ref(self, db: &dyn HirDatabase) -> TypeRef {
+        db.const_data(self.id).type_ref.clone()
+    }
 }
 impl HasVisibility for Const {
@@ -981,6 +1034,12 @@ impl Static {
    }
 }
+impl HasVisibility for Static {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        db.static_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Trait {
    pub(crate) id: TraitId,
@@ -1000,7 +1059,13 @@ impl Trait {
    }
    pub fn is_auto(self, db: &dyn HirDatabase) -> bool {
-        db.trait_data(self.id).auto
+        db.trait_data(self.id).is_auto
+    }
+}
+impl HasVisibility for Trait {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        db.trait_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
    }
 }
@@ -1406,25 +1471,12 @@ impl TypeParam {
        let resolver = self.id.parent.resolver(db.upcast());
        let krate = self.id.parent.module(db.upcast()).krate();
        let ty = params.get(local_idx)?.clone();
-        let subst = Substs::type_params(db, self.id.parent);
+        let subst = Substitution::type_params(db, self.id.parent);
        let ty = ty.subst(&subst.prefix(local_idx));
        Some(Type::new_with_resolver_inner(db, krate, &resolver, ty))
    }
 }
-impl HirDisplay for TypeParam {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        write!(f, "{}", self.name(f.db))?;
-        let bounds = f.db.generic_predicates_for_param(self.id);
-        let substs = Substs::type_params(f.db, self.id.parent);
-        let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>();
-        if !(predicates.is_empty() || f.omit_verbose_types()) {
-            write_bounds_like_dyn_trait_with_prefix(":", &predicates, f)?;
-        }
-        Ok(())
-    }
-}
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct LifetimeParam {
    pub(crate) id: LifetimeParamId,
@@ -1497,11 +1549,17 @@ impl Impl {
        };
        let mut all = Vec::new();
-        def_crates.into_iter().for_each(|id| {
+        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);
-        for id in db.crate_graph().iter() {
+        for id in def_crates
+            .iter()
+            .flat_map(|&id| Crate { id }.transitive_reverse_dependencies(db))
+            .map(|Crate { id }| id)
+            .chain(def_crates.iter().copied())
+            .unique()
+        {
            match fp {
                Some(fp) => all.extend(
                    db.trait_impls_in_crate(id).for_self_ty(fp).map(Self::from).filter(filter),
@@ -1516,7 +1574,8 @@ impl Impl {
    pub fn all_for_trait(db: &dyn HirDatabase, trait_: Trait) -> Vec<Impl> {
        let krate = trait_.module(db).krate();
        let mut all = Vec::new();
-        for Crate { id } in krate.reverse_dependencies(db).into_iter().chain(Some(krate)) {
+        for Crate { id } in krate.transitive_reverse_dependencies(db).into_iter().chain(Some(krate))
+        {
            let impls = db.trait_impls_in_crate(id);
            all.extend(impls.for_trait(trait_.id).map(Self::from))
        }
@@ -1615,7 +1674,7 @@ impl Type {
        krate: CrateId,
        def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
    ) -> Type {
-        let substs = Substs::build_for_def(db, def).fill_with_unknown().build();
+        let substs = Substitution::build_for_def(db, def).fill_with_unknown().build();
        let ty = db.ty(def.into()).subst(&substs);
        Type::new(db, krate, def, ty)
    }
@@ -1631,6 +1690,10 @@ impl Type {
        matches!(self.ty.value.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)))
+    }
    pub fn remove_ref(&self) -> Option<Type> {
        match &self.ty.value.interned(&Interner) {
            TyKind::Ref(.., ty) => Some(self.derived(ty.clone())),
@@ -1691,7 +1754,7 @@ impl Type {
    pub fn impls_trait(&self, db: &dyn HirDatabase, trait_: Trait, args: &[Type]) -> bool {
        let trait_ref = hir_ty::TraitRef {
            trait_: trait_.id,
-            substs: Substs::build_for_def(db, trait_.id)
+            substs: Substitution::build_for_def(db, trait_.id)
                .push(self.ty.value.clone())
                .fill(args.iter().map(|t| t.ty.value.clone()))
                .build(),
@@ -1715,7 +1778,7 @@ impl Type {
        args: &[Type],
        alias: TypeAlias,
    ) -> Option<Type> {
-        let subst = Substs::build_for_def(db, trait_.id)
+        let subst = Substitution::build_for_def(db, trait_.id)
            .push(self.ty.value.clone())
            .fill(args.iter().map(|t| t.ty.value.clone()))
            .build();
@@ -1982,7 +2045,7 @@ impl Type {
        fn walk_substs(
            db: &dyn HirDatabase,
            type_: &Type,
-            substs: &Substs,
+            substs: &Substitution,
            cb: &mut impl FnMut(Type),
        ) {
            for ty in substs.iter() {
@@ -2054,12 +2117,6 @@ impl Type {
    }
 }
-impl HirDisplay for Type {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        self.ty.value.hir_fmt(f)
-    }
-}
 // FIXME: closures
 #[derive(Debug)]
 pub struct Callable {
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 519339c0c..03c9371b5 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -143,6 +143,12 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.diagnostics_display_range(diagnostics)
    }
+    pub fn token_ancestors_with_macros(
+        &self,
+        token: SyntaxToken,
+    ) -> impl Iterator<Item = SyntaxNode> + '_ {
+        token.parent().into_iter().flat_map(move |it| self.ancestors_with_macros(it))
+    }
    pub fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
        self.imp.ancestors_with_macros(node)
    }
@@ -270,8 +276,8 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.scope(node)
    }
-    pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db> {
+    pub fn scope_at_offset(&self, token: &SyntaxToken, offset: TextSize) -> SemanticsScope<'db> {
-        self.imp.scope_at_offset(node, offset)
+        self.imp.scope_at_offset(&token.parent().unwrap(), offset)
    }
    pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db> {
@@ -341,7 +347,10 @@ impl<'db> SemanticsImpl<'db> {
    fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
        let _p = profile::span("descend_into_macros");
-        let parent = token.parent();
+        let parent = match token.parent() {
+            Some(it) => it,
+            None => return token,
+        };
        let sa = self.analyze(&parent);
        let token = successors(Some(InFile::new(sa.file_id, token)), |token| {
@@ -360,7 +369,9 @@ impl<'db> SemanticsImpl<'db> {
                .as_ref()?
                .map_token_down(token.as_ref())?;
-            self.cache(find_root(&token.value.parent()), token.file_id);
+            if let Some(parent) = token.value.parent() {
+                self.cache(find_root(&parent), token.file_id);
+            }
            Some(token)
        })
@@ -378,7 +389,7 @@ impl<'db> SemanticsImpl<'db> {
        // Handle macro token cases
        node.token_at_offset(offset)
            .map(|token| self.descend_into_macros(token))
-            .map(|it| self.ancestors_with_macros(it.parent()))
+            .map(|it| self.token_ancestors_with_macros(it))
            .flatten()
    }
@@ -394,6 +405,13 @@ impl<'db> SemanticsImpl<'db> {
        src.with_value(&node).original_file_range(self.db.upcast())
    }
+    fn token_ancestors_with_macros(
+        &self,
+        token: SyntaxToken,
+    ) -> impl Iterator<Item = SyntaxNode> + '_ {
+        token.parent().into_iter().flat_map(move |parent| self.ancestors_with_macros(parent))
+    }
    fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
        let node = self.find_file(node);
        node.ancestors_with_macros(self.db.upcast()).map(|it| it.value)
@@ -405,7 +423,7 @@ impl<'db> SemanticsImpl<'db> {
        offset: TextSize,
    ) -> impl Iterator<Item = SyntaxNode> + '_ {
        node.token_at_offset(offset)
-            .map(|token| self.ancestors_with_macros(token.parent()))
+            .map(|token| self.token_ancestors_with_macros(token))
            .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
    }
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 4d59293e9..117f32a9e 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -20,7 +20,7 @@ use hir_def::{
 use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
 use hir_ty::{
    diagnostics::{record_literal_missing_fields, record_pattern_missing_fields},
-    InferenceResult, Substs,
+    InferenceResult, Substitution,
 };
 use syntax::{
    ast::{self, AstNode},
@@ -329,7 +329,7 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        krate: CrateId,
-        substs: &Substs,
+        substs: &Substitution,
        variant: VariantId,
        missing_fields: Vec<LocalFieldId>,
    ) -> Vec<(Field, Type)> {
diff --git a/crates/hir_def/src/adt.rs b/crates/hir_def/src/adt.rs
index efbde17d8..1b9bb8235 100644
--- a/crates/hir_def/src/adt.rs
+++ b/crates/hir_def/src/adt.rs
@@ -31,12 +31,14 @@ pub struct StructData {
    pub name: Name,
    pub variant_data: Arc<VariantData>,
    pub repr: Option<ReprKind>,
+    pub visibility: RawVisibility,
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct EnumData {
    pub name: Name,
    pub variants: Arena<EnumVariantData>,
+    pub visibility: RawVisibility,
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -102,6 +104,7 @@ impl StructData {
            name: strukt.name.clone(),
            variant_data: Arc::new(variant_data),
            repr,
+            visibility: item_tree[strukt.visibility].clone(),
        })
    }
    pub(crate) fn union_data_query(db: &dyn DefDatabase, id: UnionId) -> Arc<StructData> {
@@ -118,6 +121,7 @@ impl StructData {
            name: union.name.clone(),
            variant_data: Arc::new(variant_data),
            repr,
+            visibility: item_tree[union.visibility].clone(),
        })
    }
 }
@@ -150,7 +154,11 @@ impl EnumData {
            }
        }
-        Arc::new(EnumData { name: enum_.name.clone(), variants })
+        Arc::new(EnumData {
+            name: enum_.name.clone(),
+            variants,
+            visibility: item_tree[enum_.visibility].clone(),
+        })
    }
    pub fn variant(&self, name: &Name) -> Option<LocalEnumVariantId> {
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 8934ae6c9..7052058f2 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -519,7 +519,7 @@ impl ExprCollector<'_> {
            }
            ast::Expr::MacroCall(e) => {
                let mut ids = vec![];
-                self.collect_macro_call(e, syntax_ptr.clone(), |this, expansion| {
+                self.collect_macro_call(e, syntax_ptr.clone(), true, |this, expansion| {
                    ids.push(match expansion {
                        Some(it) => this.collect_expr(it),
                        None => this.alloc_expr(Expr::Missing, syntax_ptr.clone()),
@@ -527,6 +527,17 @@ impl ExprCollector<'_> {
                });
                ids[0]
            }
+            ast::Expr::MacroStmts(e) => {
+                // FIXME:  these statements should be held by some hir containter
+                for stmt in e.statements() {
+                    self.collect_stmt(stmt);
+                }
+                if let Some(expr) = e.expr() {
+                    self.collect_expr(expr)
+                } else {
+                    self.alloc_expr(Expr::Missing, syntax_ptr)
+                }
+            }
        }
    }
@@ -534,6 +545,7 @@ impl ExprCollector<'_> {
        &mut self,
        e: ast::MacroCall,
        syntax_ptr: AstPtr<ast::Expr>,
+        is_error_recoverable: bool,
        mut collector: F,
    ) {
        // File containing the macro call. Expansion errors will be attached here.
@@ -567,7 +579,7 @@ impl ExprCollector<'_> {
            Some((mark, expansion)) => {
                // FIXME: Statements are too complicated to recover from error for now.
                // It is because we don't have any hygiene for local variable expansion right now.
-                if T::can_cast(syntax::SyntaxKind::MACRO_STMTS) && res.err.is_some() {
+                if !is_error_recoverable && res.err.is_some() {
                    self.expander.exit(self.db, mark);
                    collector(self, None);
                } else {
@@ -591,56 +603,55 @@ impl ExprCollector<'_> {
    }
    fn collect_stmt(&mut self, s: ast::Stmt) -> Option<Vec<Statement>> {
-        let stmt =
+        let stmt = match s {
-            match s {
+            ast::Stmt::LetStmt(stmt) => {
-                ast::Stmt::LetStmt(stmt) => {
+                self.check_cfg(&stmt)?;
-                    self.check_cfg(&stmt)?;
+                let pat = self.collect_pat_opt(stmt.pat());
-                    let pat = self.collect_pat_opt(stmt.pat());
+                let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
-                    let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
+                let initializer = stmt.initializer().map(|e| self.collect_expr(e));
-                    let initializer = stmt.initializer().map(|e| self.collect_expr(e));
+                vec![Statement::Let { pat, type_ref, initializer }]
-                    vec![Statement::Let { pat, type_ref, initializer }]
+            }
-                }
+            ast::Stmt::ExprStmt(stmt) => {
-                ast::Stmt::ExprStmt(stmt) => {
+                self.check_cfg(&stmt)?;
-                    self.check_cfg(&stmt)?;
+                // Note that macro could be expended to multiple statements
-                    // Note that macro could be expended to multiple statements
+                if let Some(ast::Expr::MacroCall(m)) = stmt.expr() {
-                    if let Some(ast::Expr::MacroCall(m)) = stmt.expr() {
+                    let syntax_ptr = AstPtr::new(&stmt.expr().unwrap());
-                        let syntax_ptr = AstPtr::new(&stmt.expr().unwrap());
+                    let mut stmts = vec![];
-                        let mut stmts = vec![];
+                    self.collect_macro_call(m, syntax_ptr.clone(), false, |this, expansion| {
-                        self.collect_macro_call(m, syntax_ptr.clone(), |this, expansion| {
+                        match expansion {
-                            match expansion {
+                            Some(expansion) => {
-                                Some(expansion) => {
+                                let statements: ast::MacroStmts = expansion;
-                                    let statements: ast::MacroStmts = expansion;
+                                statements.statements().for_each(|stmt| {
-                                    statements.statements().for_each(|stmt| {
+                                    if let Some(mut r) = this.collect_stmt(stmt) {
-                                        if let Some(mut r) = this.collect_stmt(stmt) {
+                                        stmts.append(&mut r);
-                                            stmts.append(&mut r);
-                                        }
-                                    });
-                                    if let Some(expr) = statements.expr() {
-                                        stmts.push(Statement::Expr(this.collect_expr(expr)));
                                    }
-                                }
+                                });
-                                None => {
+                                if let Some(expr) = statements.expr() {
-                                    stmts.push(Statement::Expr(
+                                    stmts.push(Statement::Expr(this.collect_expr(expr)));
-                                        this.alloc_expr(Expr::Missing, syntax_ptr.clone()),
-                                    ));
                                }
                            }
-                        });
+                            None => {
-                        stmts
+                                stmts.push(Statement::Expr(
-                    } else {
+                                    this.alloc_expr(Expr::Missing, syntax_ptr.clone()),
-                        vec![Statement::Expr(self.collect_expr_opt(stmt.expr()))]
+                                ));
-                    }
+                            }
+                        }
+                    });
+                    stmts
+                } else {
+                    vec![Statement::Expr(self.collect_expr_opt(stmt.expr()))]
                }
-                ast::Stmt::Item(item) => {
+            }
-                    self.check_cfg(&item)?;
+            ast::Stmt::Item(item) => {
+                self.check_cfg(&item)?;
-                    return None;
+                return None;
-                }
+            }
-            };
+        };
        Some(stmt)
    }
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index aea53d527..74a2194e5 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -9,7 +9,7 @@ use crate::{
    attr::Attrs,
    body::Expander,
    db::DefDatabase,
-    item_tree::{AssocItem, ItemTreeId, ModItem},
+    item_tree::{AssocItem, FunctionQualifier, ItemTreeId, ModItem},
    type_ref::{TypeBound, TypeRef},
    visibility::RawVisibility,
    AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
@@ -26,9 +26,9 @@ pub struct FunctionData {
    /// can be called as a method.
    pub has_self_param: bool,
    pub has_body: bool,
-    pub is_unsafe: bool,
+    pub qualifier: FunctionQualifier,
+    pub is_in_extern_block: bool,
    pub is_varargs: bool,
-    pub is_extern: bool,
    pub visibility: RawVisibility,
 }
@@ -46,9 +46,9 @@ impl FunctionData {
            attrs: item_tree.attrs(db, krate, ModItem::from(loc.id.value).into()),
            has_self_param: func.has_self_param,
            has_body: func.has_body,
-            is_unsafe: func.is_unsafe,
+            qualifier: func.qualifier.clone(),
+            is_in_extern_block: func.is_in_extern_block,
            is_varargs: func.is_varargs,
-            is_extern: func.is_extern,
            visibility: item_tree[func.visibility].clone(),
        })
    }
@@ -87,7 +87,10 @@ impl TypeAliasData {
 pub struct TraitData {
    pub name: Name,
    pub items: Vec<(Name, AssocItemId)>,
-    pub auto: bool,
+    pub is_auto: bool,
+    pub is_unsafe: bool,
+    pub visibility: RawVisibility,
+    pub bounds: Box<[TypeBound]>,
 }
 impl TraitData {
@@ -96,10 +99,13 @@ impl TraitData {
        let item_tree = db.item_tree(tr_loc.id.file_id);
        let tr_def = &item_tree[tr_loc.id.value];
        let name = tr_def.name.clone();
-        let auto = tr_def.auto;
+        let is_auto = tr_def.is_auto;
+        let is_unsafe = tr_def.is_unsafe;
        let module_id = tr_loc.container;
        let container = AssocContainerId::TraitId(tr);
        let mut expander = Expander::new(db, tr_loc.id.file_id, module_id);
+        let visibility = item_tree[tr_def.visibility].clone();
+        let bounds = tr_def.bounds.clone();
        let items = collect_items(
            db,
@@ -111,7 +117,7 @@ impl TraitData {
            100,
        );
-        Arc::new(TraitData { name, items, auto })
+        Arc::new(TraitData { name, items, is_auto, is_unsafe, visibility, bounds })
    }
    pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 09bcb10dc..7bb22c4c4 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -24,7 +24,7 @@ use la_arena::{Arena, Idx, RawIdx};
 use profile::Count;
 use rustc_hash::FxHashMap;
 use smallvec::SmallVec;
-use syntax::{ast, match_ast, SyntaxKind};
+use syntax::{ast, match_ast, SmolStr, SyntaxKind};
 use crate::{
    attr::{Attrs, RawAttrs},
@@ -110,6 +110,11 @@ impl ItemTree {
                    // still need to collect inner items.
                    ctx.lower_inner_items(e.syntax())
                },
+                ast::ExprStmt(stmt) => {
+                    // Macros can expand to stmt. We return an empty item tree in this case, but
+                    // still need to collect inner items.
+                    ctx.lower_inner_items(stmt.syntax())
+                },
                _ => {
                    panic!("cannot create item tree from {:?} {}", syntax, syntax);
                },
@@ -551,16 +556,25 @@ pub struct Function {
    pub generic_params: GenericParamsId,
    pub has_self_param: bool,
    pub has_body: bool,
-    pub is_unsafe: bool,
+    pub qualifier: FunctionQualifier,
    /// Whether the function is located in an `extern` block (*not* whether it is an
    /// `extern "abi" fn`).
-    pub is_extern: bool,
+    pub is_in_extern_block: bool,
    pub params: Box<[Idx<TypeRef>]>,
    pub is_varargs: bool,
    pub ret_type: Idx<TypeRef>,
    pub ast_id: FileAstId<ast::Fn>,
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FunctionQualifier {
+    pub is_default: bool,
+    pub is_const: bool,
+    pub is_async: bool,
+    pub is_unsafe: bool,
+    pub abi: Option<SmolStr>,
+}
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Struct {
    pub name: Name,
@@ -624,7 +638,9 @@ pub struct Trait {
    pub name: Name,
    pub visibility: RawVisibilityId,
    pub generic_params: GenericParamsId,
-    pub auto: bool,
+    pub is_auto: bool,
+    pub is_unsafe: bool,
+    pub bounds: Box<[TypeBound]>,
    pub items: Box<[AssocItem]>,
    pub ast_id: FileAstId<ast::Trait>,
 }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 240fdacf9..7e91b991d 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -391,14 +391,33 @@ impl Ctx {
        let has_body = func.body().is_some();
        let ast_id = self.source_ast_id_map.ast_id(func);
+        let qualifier = FunctionQualifier {
+            is_default: func.default_token().is_some(),
+            is_const: func.const_token().is_some(),
+            is_async: func.async_token().is_some(),
+            is_unsafe: func.unsafe_token().is_some(),
+            abi: func.abi().map(|abi| {
+                // FIXME: Abi::abi() -> Option<SyntaxToken>?
+                match abi.syntax().last_token() {
+                    Some(tok) if tok.kind() == SyntaxKind::STRING => {
+                        // FIXME: Better way to unescape?
+                        tok.text().trim_matches('"').into()
+                    }
+                    _ => {
+                        // `extern` default to be `extern "C"`.
+                        "C".into()
+                    }
+                }
+            }),
+        };
        let mut res = Function {
            name,
            visibility,
            generic_params: GenericParamsId::EMPTY,
            has_self_param,
            has_body,
-            is_unsafe: func.unsafe_token().is_some(),
+            qualifier,
-            is_extern: false,
+            is_in_extern_block: false,
            params,
            is_varargs,
            ret_type,
@@ -481,7 +500,9 @@ impl Ctx {
        let visibility = self.lower_visibility(trait_def);
        let generic_params =
            self.lower_generic_params_and_inner_items(GenericsOwner::Trait(trait_def), trait_def);
-        let auto = trait_def.auto_token().is_some();
+        let is_auto = trait_def.auto_token().is_some();
+        let is_unsafe = trait_def.unsafe_token().is_some();
+        let bounds = self.lower_type_bounds(trait_def);
        let items = trait_def.assoc_item_list().map(|list| {
            self.with_inherited_visibility(visibility, |this| {
                list.assoc_items()
@@ -501,7 +522,9 @@ impl Ctx {
            name,
            visibility,
            generic_params,
-            auto,
+            is_auto,
+            is_unsafe,
+            bounds: bounds.into(),
            items: items.unwrap_or_default(),
            ast_id,
        };
@@ -608,8 +631,8 @@ impl Ctx {
                        ast::ExternItem::Fn(ast) => {
                            let func_id = self.lower_function(&ast)?;
                            let func = &mut self.data().functions[func_id.index];
-                            func.is_unsafe = is_intrinsic_fn_unsafe(&func.name);
+                            func.qualifier.is_unsafe = is_intrinsic_fn_unsafe(&func.name);
-                            func.is_extern = true;
+                            func.is_in_extern_block = true;
                            func_id.into()
                        }
                        ast::ExternItem::Static(ast) => {
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 0e60dc2b6..8c923bb7b 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -9,7 +9,10 @@ use std::{
 use crate::{body::LowerCtx, type_ref::LifetimeRef};
 use base_db::CrateId;
-use hir_expand::{hygiene::Hygiene, name::Name};
+use hir_expand::{
+    hygiene::Hygiene,
+    name::{name, Name},
+};
 use syntax::ast;
 use crate::{
@@ -209,6 +212,12 @@ impl Path {
        };
        Some(res)
    }
+    pub fn is_self_type(&self) -> bool {
+        self.type_anchor.is_none()
+            && self.generic_args == &[None]
+            && self.mod_path.as_ident() == Some(&name!(Self))
+    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 9086e6c17..a3070f1f9 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -401,13 +401,14 @@ fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
    match parent.kind() {
        MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
+        MACRO_STMTS => FragmentKind::Statement,
        ITEM_LIST => FragmentKind::Items,
        LET_STMT => {
            // FIXME: Handle Pattern
            FragmentKind::Expr
        }
        EXPR_STMT => FragmentKind::Statements,
-        BLOCK_EXPR => FragmentKind::Expr,
+        BLOCK_EXPR => FragmentKind::Statements,
        ARG_LIST => FragmentKind::Expr,
        TRY_EXPR => FragmentKind::Expr,
        TUPLE_EXPR => FragmentKind::Expr,
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index e388ddacc..eee430af1 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -510,7 +510,10 @@ impl InFile<SyntaxToken> {
        self,
        db: &dyn db::AstDatabase,
    ) -> impl Iterator<Item = InFile<SyntaxNode>> + '_ {
-        self.map(|it| it.parent()).ancestors_with_macros(db)
+        self.value
+            .parent()
+            .into_iter()
+            .flat_map(move |parent| InFile::new(self.file_id, parent).ancestors_with_macros(db))
    }
 }
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index 56c6b92d4..bd2ff5d38 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -15,7 +15,7 @@ use crate::{
    to_assoc_type_id,
    traits::{InEnvironment, Solution},
    utils::generics,
-    BoundVar, Canonical, DebruijnIndex, Interner, Obligation, Substs, TraitRef, Ty, TyKind,
+    BoundVar, Canonical, DebruijnIndex, Interner, Obligation, Substitution, TraitRef, Ty, TyKind,
 };
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -65,7 +65,7 @@ fn deref_by_trait(
    // FIXME make the Canonical / bound var handling nicer
    let parameters =
-        Substs::build_for_generics(&generic_params).push(ty.value.value.clone()).build();
+        Substitution::build_for_generics(&generic_params).push(ty.value.value.clone()).build();
    // Check that the type implements Deref at all
    let trait_ref = TraitRef { trait_: deref_trait, substs: parameters.clone() };
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index 3605ca581..982ad5b9e 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -91,7 +91,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    fn validate_func(&mut self, func: FunctionId) {
        let data = self.db.function_data(func);
-        if data.is_extern {
+        if data.is_in_extern_block {
            cov_mark::hit!(extern_func_incorrect_case_ignored);
            return;
        }
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index 20bb64827..44a7e5506 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -32,7 +32,7 @@ impl<'a, 'b> UnsafeValidator<'a, 'b> {
        let def = self.owner.into();
        let unsafe_expressions = unsafe_expressions(db, self.infer.as_ref(), def);
        let is_unsafe = match self.owner {
-            DefWithBodyId::FunctionId(it) => db.function_data(it).is_unsafe,
+            DefWithBodyId::FunctionId(it) => db.function_data(it).qualifier.is_unsafe,
            DefWithBodyId::StaticId(_) | DefWithBodyId::ConstId(_) => false,
        };
        if is_unsafe
@@ -86,7 +86,7 @@ fn walk_unsafe(
    match expr {
        &Expr::Call { callee, .. } => {
            if let Some(func) = infer[callee].as_fn_def(db) {
-                if db.function_data(func).is_unsafe {
+                if db.function_data(func).qualifier.is_unsafe {
                    unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block });
                }
            }
@@ -103,7 +103,7 @@ fn walk_unsafe(
        Expr::MethodCall { .. } => {
            if infer
                .method_resolution(current)
-                .map(|func| db.function_data(func).is_unsafe)
+                .map(|func| db.function_data(func).qualifier.is_unsafe)
                .unwrap_or(false)
            {
                unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block });
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index c1062387e..7ce0f864c 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -5,7 +5,13 @@ use std::{borrow::Cow, fmt};
 use arrayvec::ArrayVec;
 use chalk_ir::Mutability;
 use hir_def::{
-    db::DefDatabase, find_path, generics::TypeParamProvenance, item_scope::ItemInNs,
+    db::DefDatabase,
+    find_path,
+    generics::TypeParamProvenance,
+    item_scope::ItemInNs,
+    path::{GenericArg, Path, PathKind},
+    type_ref::{TypeBound, TypeRef},
+    visibility::Visibility,
    AssocContainerId, Lookup, ModuleId, TraitId,
 };
 use hir_expand::name::Name;
@@ -14,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, AliasTy, CallableDefId,
    CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation, OpaqueTy,
-    ProjectionTy, Scalar, Substs, TraitRef, Ty, TyKind,
+    ProjectionTy, Scalar, Substitution, TraitRef, Ty, TyKind,
 };
 pub struct HirFormatter<'a> {
@@ -232,7 +238,7 @@ where
 const TYPE_HINT_TRUNCATION: &str = "…";
-impl HirDisplay for &Ty {
+impl<T: HirDisplay> HirDisplay for &'_ T {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        HirDisplay::hir_fmt(*self, f)
    }
@@ -556,7 +562,7 @@ impl HirDisplay for Ty {
                    }
                    TypeParamProvenance::ArgumentImplTrait => {
                        let bounds = f.db.generic_predicates_for_param(id);
-                        let substs = Substs::type_params_for_generics(f.db, &generics);
+                        let substs = Substitution::type_params_for_generics(f.db, &generics);
                        write_bounds_like_dyn_trait_with_prefix(
                            "impl",
                            &bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(),
@@ -761,12 +767,6 @@ impl HirDisplay for TraitRef {
    }
 }
-impl HirDisplay for &GenericPredicate {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        HirDisplay::hir_fmt(*self, f)
-    }
-}
 impl HirDisplay for GenericPredicate {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
@@ -825,3 +825,190 @@ impl HirDisplay for Obligation {
        }
    }
 }
+pub fn write_visibility(
+    module_id: ModuleId,
+    vis: Visibility,
+    f: &mut HirFormatter,
+) -> Result<(), HirDisplayError> {
+    match vis {
+        Visibility::Public => write!(f, "pub "),
+        Visibility::Module(vis_id) => {
+            let def_map = module_id.def_map(f.db.upcast());
+            let root_module_id = def_map.module_id(def_map.root());
+            if vis_id == module_id {
+                // pub(self) or omitted
+                Ok(())
+            } else if root_module_id == vis_id {
+                write!(f, "pub(crate) ")
+            } else if module_id.containing_module(f.db.upcast()) == Some(vis_id) {
+                write!(f, "pub(super) ")
+            } else {
+                write!(f, "pub(in ...) ")
+            }
+        }
+    }
+}
+impl HirDisplay for TypeRef {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        match self {
+            TypeRef::Never => write!(f, "!")?,
+            TypeRef::Placeholder => write!(f, "_")?,
+            TypeRef::Tuple(elems) => {
+                write!(f, "(")?;
+                f.write_joined(elems, ", ")?;
+                if elems.len() == 1 {
+                    write!(f, ",")?;
+                }
+                write!(f, ")")?;
+            }
+            TypeRef::Path(path) => path.hir_fmt(f)?,
+            TypeRef::RawPtr(inner, mutability) => {
+                let mutability = match mutability {
+                    hir_def::type_ref::Mutability::Shared => "*const ",
+                    hir_def::type_ref::Mutability::Mut => "*mut ",
+                };
+                write!(f, "{}", mutability)?;
+                inner.hir_fmt(f)?;
+            }
+            TypeRef::Reference(inner, lifetime, mutability) => {
+                let mutability = match mutability {
+                    hir_def::type_ref::Mutability::Shared => "",
+                    hir_def::type_ref::Mutability::Mut => "mut ",
+                };
+                write!(f, "&")?;
+                if let Some(lifetime) = lifetime {
+                    write!(f, "{} ", lifetime.name)?;
+                }
+                write!(f, "{}", mutability)?;
+                inner.hir_fmt(f)?;
+            }
+            TypeRef::Array(inner) => {
+                write!(f, "[")?;
+                inner.hir_fmt(f)?;
+                // FIXME: Array length?
+                write!(f, "; _]")?;
+            }
+            TypeRef::Slice(inner) => {
+                write!(f, "[")?;
+                inner.hir_fmt(f)?;
+                write!(f, "]")?;
+            }
+            TypeRef::Fn(tys, is_varargs) => {
+                // FIXME: Function pointer qualifiers.
+                write!(f, "fn(")?;
+                f.write_joined(&tys[..tys.len() - 1], ", ")?;
+                if *is_varargs {
+                    write!(f, "{}...", if tys.len() == 1 { "" } else { ", " })?;
+                }
+                write!(f, ")")?;
+                let ret_ty = tys.last().unwrap();
+                match ret_ty {
+                    TypeRef::Tuple(tup) if tup.is_empty() => {}
+                    _ => {
+                        write!(f, " -> ")?;
+                        ret_ty.hir_fmt(f)?;
+                    }
+                }
+            }
+            TypeRef::ImplTrait(bounds) => {
+                write!(f, "impl ")?;
+                f.write_joined(bounds, " + ")?;
+            }
+            TypeRef::DynTrait(bounds) => {
+                write!(f, "dyn ")?;
+                f.write_joined(bounds, " + ")?;
+            }
+            TypeRef::Error => write!(f, "{{error}}")?,
+        }
+        Ok(())
+    }
+}
+impl HirDisplay for TypeBound {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        match self {
+            TypeBound::Path(path) => path.hir_fmt(f),
+            TypeBound::Lifetime(lifetime) => write!(f, "{}", lifetime.name),
+            TypeBound::Error => write!(f, "{{error}}"),
+        }
+    }
+}
+impl HirDisplay for Path {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        match (self.type_anchor(), self.kind()) {
+            (Some(anchor), _) => {
+                write!(f, "<")?;
+                anchor.hir_fmt(f)?;
+                write!(f, ">")?;
+            }
+            (_, PathKind::Plain) => {}
+            (_, PathKind::Abs) => write!(f, "::")?,
+            (_, PathKind::Crate) => write!(f, "crate")?,
+            (_, PathKind::Super(0)) => write!(f, "self")?,
+            (_, PathKind::Super(n)) => {
+                write!(f, "super")?;
+                for _ in 0..*n {
+                    write!(f, "::super")?;
+                }
+            }
+            (_, PathKind::DollarCrate(_)) => write!(f, "{{extern_crate}}")?,
+        }
+        for (seg_idx, segment) in self.segments().iter().enumerate() {
+            if seg_idx != 0 {
+                write!(f, "::")?;
+            }
+            write!(f, "{}", segment.name)?;
+            if let Some(generic_args) = segment.args_and_bindings {
+                // We should be in type context, so format as `Foo<Bar>` instead of `Foo::<Bar>`.
+                // Do we actually format expressions?
+                write!(f, "<")?;
+                let mut first = true;
+                for arg in &generic_args.args {
+                    if first {
+                        first = false;
+                        if generic_args.has_self_type {
+                            // FIXME: Convert to `<Ty as Trait>` form.
+                            write!(f, "Self = ")?;
+                        }
+                    } else {
+                        write!(f, ", ")?;
+                    }
+                    arg.hir_fmt(f)?;
+                }
+                for binding in &generic_args.bindings {
+                    if first {
+                        first = false;
+                    } else {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{}", binding.name)?;
+                    match &binding.type_ref {
+                        Some(ty) => {
+                            write!(f, " = ")?;
+                            ty.hir_fmt(f)?
+                        }
+                        None => {
+                            write!(f, ": ")?;
+                            f.write_joined(&binding.bounds, " + ")?;
+                        }
+                    }
+                }
+                write!(f, ">")?;
+            }
+        }
+        Ok(())
+    }
+}
+impl HirDisplay for GenericArg {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        match self {
+            GenericArg::Type(ty) => ty.hir_fmt(f),
+            GenericArg::Lifetime(lifetime) => write!(f, "{}", lifetime.name),
+        }
+    }
+}
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 9c385b845..2610c9279 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -38,7 +38,7 @@ use syntax::SmolStr;
 use super::{
    traits::{Guidance, Obligation, ProjectionPredicate, Solution},
-    InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk,
+    InEnvironment, ProjectionTy, Substitution, TraitEnvironment, TraitRef, Ty, TypeWalk,
 };
 use crate::{
    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
@@ -390,7 +390,7 @@ impl<'a> InferenceContext<'a> {
                    _ => panic!("resolve_associated_type called with non-associated type"),
                };
                let ty = self.table.new_type_var();
-                let substs = Substs::build_for_def(self.db, res_assoc_ty)
+                let substs = Substitution::build_for_def(self.db, res_assoc_ty)
                    .push(inner_ty)
                    .fill(params.iter().cloned())
                    .build();
@@ -469,7 +469,7 @@ impl<'a> InferenceContext<'a> {
            }
            TypeNs::SelfType(impl_id) => {
                let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
-                let substs = Substs::type_params_for_generics(self.db, &generics);
+                let substs = Substitution::type_params_for_generics(self.db, &generics);
                let ty = self.db.impl_self_ty(impl_id).subst(&substs);
                match unresolved {
                    None => {
@@ -496,7 +496,7 @@ impl<'a> InferenceContext<'a> {
                }
            }
            TypeNs::TypeAliasId(it) => {
-                let substs = Substs::build_for_def(self.db, it)
+                let substs = Substitution::build_for_def(self.db, it)
                    .fill(std::iter::repeat_with(|| self.table.new_type_var()))
                    .build();
                let ty = self.db.ty(it.into()).subst(&substs);
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 137419264..b1f98c507 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -7,7 +7,9 @@
 use chalk_ir::{Mutability, TyVariableKind};
 use hir_def::lang_item::LangItemTarget;
-use crate::{autoderef, traits::Solution, Interner, Obligation, Substs, TraitRef, Ty, TyKind};
+use crate::{
+    autoderef, traits::Solution, Interner, Obligation, Substitution, TraitRef, Ty, TyKind,
+};
 use super::{InEnvironment, InferenceContext};
@@ -134,7 +136,7 @@ impl<'a> InferenceContext<'a> {
            return None;
        }
-        let substs = Substs::build_for_generics(&generic_params)
+        let substs = Substitution::build_for_generics(&generic_params)
            .push(from_ty.clone())
            .push(to_ty.clone())
            .build();
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index f40dec17f..0be8c5a90 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -21,8 +21,8 @@ use crate::{
    to_assoc_type_id,
    traits::{chalk::from_chalk, FnTrait, InEnvironment},
    utils::{generics, variant_data, Generics},
-    AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar, Substs,
+    AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar,
-    TraitRef, Ty, TyKind,
+    Substitution, TraitRef, Ty, TyKind,
 };
 use super::{
@@ -77,7 +77,7 @@ impl<'a> InferenceContext<'a> {
            return None;
        }
-        let mut param_builder = Substs::builder(num_args);
+        let mut param_builder = Substitution::builder(num_args);
        let mut arg_tys = vec![];
        for _ in 0..num_args {
            let arg = self.table.new_type_var();
@@ -87,7 +87,7 @@ impl<'a> InferenceContext<'a> {
        let parameters = param_builder.build();
        let arg_ty = TyKind::Tuple(num_args, parameters).intern(&Interner);
        let substs =
-            Substs::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
+            Substitution::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
        let trait_env = Arc::clone(&self.trait_env);
        let implements_fn_trait =
@@ -181,7 +181,7 @@ impl<'a> InferenceContext<'a> {
                let inner_ty = self.infer_expr(*body, &Expectation::none());
                let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body);
                let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();
-                TyKind::OpaqueType(opaque_ty_id, Substs::single(inner_ty)).intern(&Interner)
+                TyKind::OpaqueType(opaque_ty_id, Substitution::single(inner_ty)).intern(&Interner)
            }
            Expr::Loop { body, label } => {
                self.breakables.push(BreakableContext {
@@ -262,12 +262,12 @@ impl<'a> InferenceContext<'a> {
                let sig_ty = TyKind::Function(FnPointer {
                    num_args: sig_tys.len() - 1,
                    sig: FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: false },
-                    substs: Substs(sig_tys.clone().into()),
+                    substs: Substitution(sig_tys.clone().into()),
                })
                .intern(&Interner);
                let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into();
                let closure_ty =
-                    TyKind::Closure(closure_id, Substs::single(sig_ty)).intern(&Interner);
+                    TyKind::Closure(closure_id, Substitution::single(sig_ty)).intern(&Interner);
                // Eagerly try to relate the closure type with the expected
                // type, otherwise we often won't have enough information to
@@ -402,7 +402,7 @@ impl<'a> InferenceContext<'a> {
                self.unify(&ty, &expected.ty);
-                let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
+                let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty);
                let field_types = def_id.map(|it| self.db.field_types(it)).unwrap_or_default();
                let variant_data = def_id.map(|it| variant_data(self.db.upcast(), it));
                for field in fields.iter() {
@@ -511,7 +511,8 @@ impl<'a> InferenceContext<'a> {
            Expr::Box { expr } => {
                let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
                if let Some(box_) = self.resolve_boxed_box() {
-                    let mut sb = Substs::builder(generics(self.db.upcast(), box_.into()).len());
+                    let mut sb =
+                        Substitution::builder(generics(self.db.upcast(), box_.into()).len());
                    sb = sb.push(inner_ty);
                    match self.db.generic_defaults(box_.into()).as_ref() {
                        [_, alloc_ty, ..] if !alloc_ty.value.is_unknown() => {
@@ -610,31 +611,31 @@ impl<'a> InferenceContext<'a> {
                let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect));
                match (range_type, lhs_ty, rhs_ty) {
                    (RangeOp::Exclusive, None, None) => match self.resolve_range_full() {
-                        Some(adt) => Ty::adt_ty(adt, Substs::empty()),
+                        Some(adt) => Ty::adt_ty(adt, Substitution::empty()),
                        None => self.err_ty(),
                    },
                    (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {
-                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
+                        Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
                        None => self.err_ty(),
                    },
                    (RangeOp::Inclusive, None, Some(ty)) => {
                        match self.resolve_range_to_inclusive() {
-                            Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
+                            Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
                            None => self.err_ty(),
                        }
                    }
                    (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {
-                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
+                        Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
                        None => self.err_ty(),
                    },
                    (RangeOp::Inclusive, Some(_), Some(ty)) => {
                        match self.resolve_range_inclusive() {
-                            Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
+                            Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
                            None => self.err_ty(),
                        }
                    }
                    (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {
-                        Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
+                        Some(adt) => Ty::adt_ty(adt, Substitution::single(ty)),
                        None => self.err_ty(),
                    },
                    (RangeOp::Inclusive, _, None) => self.err_ty(),
@@ -681,7 +682,7 @@ impl<'a> InferenceContext<'a> {
                    self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone()));
                }
-                TyKind::Tuple(tys.len(), Substs(tys.into())).intern(&Interner)
+                TyKind::Tuple(tys.len(), Substitution(tys.into())).intern(&Interner)
            }
            Expr::Array(array) => {
                let elem_ty = match expected.ty.interned(&Interner) {
@@ -887,7 +888,7 @@ impl<'a> InferenceContext<'a> {
        def_generics: Option<Generics>,
        generic_args: Option<&GenericArgs>,
        receiver_ty: &Ty,
-    ) -> Substs {
+    ) -> Substitution {
        let (parent_params, self_params, type_params, impl_trait_params) =
            def_generics.as_ref().map_or((0, 0, 0, 0), |g| g.provenance_split());
        assert_eq!(self_params, 0); // method shouldn't have another Self param
@@ -926,7 +927,7 @@ impl<'a> InferenceContext<'a> {
            substs.push(self.err_ty());
        }
        assert_eq!(substs.len(), total_len);
-        Substs(substs.into())
+        Substitution(substs.into())
    }
    fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 9e8ca18ef..befa0d69b 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -12,7 +12,9 @@ use hir_def::{
 use hir_expand::name::Name;
 use super::{BindingMode, Expectation, InferenceContext};
-use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substs, Ty, TyKind};
+use crate::{
+    lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substitution, Ty, TyKind,
+};
 impl<'a> InferenceContext<'a> {
    fn infer_tuple_struct_pat(
@@ -31,7 +33,7 @@ impl<'a> InferenceContext<'a> {
        }
        self.unify(&ty, expected);
-        let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
+        let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty);
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        let (pre, post) = match ellipsis {
@@ -70,7 +72,7 @@ impl<'a> InferenceContext<'a> {
        self.unify(&ty, expected);
-        let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
+        let substs = ty.substs().cloned().unwrap_or_else(Substitution::empty);
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        for subpat in subpats {
@@ -138,7 +140,7 @@ impl<'a> InferenceContext<'a> {
                inner_tys.extend(expectations_iter.by_ref().take(n_uncovered_patterns).cloned());
                inner_tys.extend(post.iter().zip(expectations_iter).map(infer_pat));
-                TyKind::Tuple(inner_tys.len(), Substs(inner_tys.into())).intern(&Interner)
+                TyKind::Tuple(inner_tys.len(), Substitution(inner_tys.into())).intern(&Interner)
            }
            Pat::Or(ref pats) => {
                if let Some((first_pat, rest)) = pats.split_first() {
@@ -237,7 +239,7 @@ impl<'a> InferenceContext<'a> {
                    };
                    let inner_ty = self.infer_pat(*inner, &inner_expected, default_bm);
-                    Ty::adt_ty(box_adt, Substs::single(inner_ty))
+                    Ty::adt_ty(box_adt, Substitution::single(inner_ty))
                }
                None => self.err_ty(),
            },
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs
index af108fb6c..ea01d6238 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -9,7 +9,7 @@ use hir_def::{
 };
 use hir_expand::name::Name;
-use crate::{method_resolution, Interner, Substs, Ty, TyKind, ValueTyDefId};
+use crate::{method_resolution, Interner, Substitution, Ty, TyKind, ValueTyDefId};
 use super::{ExprOrPatId, InferenceContext, TraitRef};
@@ -79,7 +79,7 @@ impl<'a> InferenceContext<'a> {
            }
            ValueNs::ImplSelf(impl_id) => {
                let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
-                let substs = Substs::type_params_for_generics(self.db, &generics);
+                let substs = Substitution::type_params_for_generics(self.db, &generics);
                let ty = self.db.impl_self_ty(impl_id).subst(&substs);
                if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() {
                    let ty = self.db.value_ty(struct_id.into()).subst(&substs);
@@ -94,10 +94,10 @@ impl<'a> InferenceContext<'a> {
        let ty = self.db.value_ty(typable);
        // self_subst is just for the parent
-        let parent_substs = self_subst.unwrap_or_else(Substs::empty);
+        let parent_substs = self_subst.unwrap_or_else(Substitution::empty);
        let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
        let substs = ctx.substs_from_path(path, typable, true);
-        let full_substs = Substs::builder(substs.len())
+        let full_substs = Substitution::builder(substs.len())
            .use_parent_substs(&parent_substs)
            .fill(substs.0[parent_substs.len()..].iter().cloned())
            .build();
@@ -111,7 +111,7 @@ impl<'a> InferenceContext<'a> {
        path: &Path,
        remaining_index: usize,
        id: ExprOrPatId,
-    ) -> Option<(ValueNs, Option<Substs>)> {
+    ) -> Option<(ValueNs, Option<Substitution>)> {
        assert!(remaining_index < path.segments().len());
        // there may be more intermediate segments between the resolved one and
        // the end. Only the last segment needs to be resolved to a value; from
@@ -164,7 +164,7 @@ impl<'a> InferenceContext<'a> {
        trait_ref: TraitRef,
        segment: PathSegment<'_>,
        id: ExprOrPatId,
-    ) -> Option<(ValueNs, Option<Substs>)> {
+    ) -> Option<(ValueNs, Option<Substitution>)> {
        let trait_ = trait_ref.trait_;
        let item =
            self.db.trait_data(trait_).items.iter().map(|(_name, id)| (*id)).find_map(|item| {
@@ -208,7 +208,7 @@ impl<'a> InferenceContext<'a> {
        ty: Ty,
        name: &Name,
        id: ExprOrPatId,
-    ) -> Option<(ValueNs, Option<Substs>)> {
+    ) -> Option<(ValueNs, Option<Substitution>)> {
        if let TyKind::Unknown = ty.interned(&Interner) {
            return None;
        }
@@ -241,7 +241,7 @@ impl<'a> InferenceContext<'a> {
                };
                let substs = match container {
                    AssocContainerId::ImplId(impl_id) => {
-                        let impl_substs = Substs::build_for_def(self.db, impl_id)
+                        let impl_substs = Substitution::build_for_def(self.db, impl_id)
                            .fill(iter::repeat_with(|| self.table.new_type_var()))
                            .build();
                        let impl_self_ty = self.db.impl_self_ty(impl_id).subst(&impl_substs);
@@ -250,7 +250,7 @@ impl<'a> InferenceContext<'a> {
                    }
                    AssocContainerId::TraitId(trait_) => {
                        // we're picking this method
-                        let trait_substs = Substs::build_for_def(self.db, trait_)
+                        let trait_substs = Substitution::build_for_def(self.db, trait_)
                            .push(ty.clone())
                            .fill(std::iter::repeat_with(|| self.table.new_type_var()))
                            .build();
@@ -274,7 +274,7 @@ impl<'a> InferenceContext<'a> {
        ty: &Ty,
        name: &Name,
        id: ExprOrPatId,
-    ) -> Option<(ValueNs, Option<Substs>)> {
+    ) -> Option<(ValueNs, Option<Substitution>)> {
        let (enum_id, subst) = match ty.as_adt() {
            Some((AdtId::EnumId(e), subst)) => (e, subst),
            _ => return None,
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 7795f446f..b2d4f67b3 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -8,7 +8,7 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use super::{InferenceContext, Obligation};
 use crate::{
    BoundVar, Canonical, DebruijnIndex, FnPointer, GenericPredicate, InEnvironment, InferenceVar,
-    Interner, Scalar, Substs, Ty, TyKind, TypeWalk,
+    Interner, Scalar, Substitution, Ty, TyKind, TypeWalk,
 };
 impl<'a> InferenceContext<'a> {
@@ -123,10 +123,10 @@ impl<T> Canonicalized<T> {
    pub(super) fn apply_solution(
        &self,
        ctx: &mut InferenceContext<'_>,
-        solution: Canonical<Substs>,
+        solution: Canonical<Substitution>,
    ) {
        // the solution may contain new variables, which we need to convert to new inference vars
-        let new_vars = Substs(
+        let new_vars = Substitution(
            solution
                .kinds
                .iter()
@@ -147,9 +147,9 @@ impl<T> Canonicalized<T> {
    }
 }
-pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
+pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substitution> {
    let mut table = InferenceTable::new();
-    let vars = Substs(
+    let vars = Substitution(
        tys.kinds
            .iter()
            // we always use type vars here because we want everything to
@@ -173,7 +173,7 @@ pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
        }
    }
    Some(
-        Substs::builder(tys.kinds.len())
+        Substitution::builder(tys.kinds.len())
            .fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone())))
            .build(),
    )
@@ -264,8 +264,8 @@ impl InferenceTable {
    pub(crate) fn unify_substs(
        &mut self,
-        substs1: &Substs,
+        substs1: &Substitution,
-        substs2: &Substs,
+        substs2: &Substitution,
        depth: usize,
    ) -> bool {
        substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth))
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 850385280..52b498ff7 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -67,7 +67,7 @@ pub enum Lifetime {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct OpaqueTy {
    pub opaque_ty_id: OpaqueTyId,
-    pub substitution: Substs,
+    pub substitution: Substitution,
 }
 /// A "projection" type corresponds to an (unnormalized)
@@ -76,7 +76,7 @@ pub struct OpaqueTy {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct ProjectionTy {
    pub associated_ty_id: AssocTypeId,
-    pub substitution: Substs,
+    pub substitution: Substitution,
 }
 impl ProjectionTy {
@@ -112,7 +112,7 @@ pub type FnSig = chalk_ir::FnSig<Interner>;
 pub struct FnPointer {
    pub num_args: usize,
    pub sig: FnSig,
-    pub substs: Substs,
+    pub substs: Substitution,
 }
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -137,19 +137,19 @@ pub enum AliasTy {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum TyKind {
    /// Structures, enumerations and unions.
-    Adt(AdtId<Interner>, Substs),
+    Adt(AdtId<Interner>, Substitution),
    /// Represents an associated item like `Iterator::Item`.  This is used
    /// when we have tried to normalize a projection like `T::Item` but
    /// couldn't find a better representation.  In that case, we generate
    /// an **application type** like `(Iterator::Item)<T>`.
-    AssociatedType(AssocTypeId, Substs),
+    AssociatedType(AssocTypeId, Substitution),
    /// a scalar type like `bool` or `u32`
    Scalar(Scalar),
    /// A tuple type.  For example, `(i32, bool)`.
-    Tuple(usize, Substs),
+    Tuple(usize, Substitution),
    /// An array with the given length. Written as `[T; n]`.
    Array(Ty),
@@ -169,7 +169,7 @@ pub enum TyKind {
    /// analogous to the `AssociatedType` type constructor.
    /// It is also used as the type of async block, with one type parameter
    /// representing the Future::Output type.
-    OpaqueType(OpaqueTyId, Substs),
+    OpaqueType(OpaqueTyId, Substitution),
    /// The anonymous type of a function declaration/definition. Each
    /// function has a unique type, which is output (for a function
@@ -183,7 +183,7 @@ pub enum TyKind {
    /// fn foo() -> i32 { 1 }
    /// let bar = foo; // bar: fn() -> i32 {foo}
    /// ```
-    FnDef(FnDefId, Substs),
+    FnDef(FnDefId, Substitution),
    /// The pointee of a string slice. Written as `str`.
    Str,
@@ -195,7 +195,7 @@ pub enum TyKind {
    ///
    /// The closure signature is stored in a `FnPtr` type in the first type
    /// parameter.
-    Closure(ClosureId, Substs),
+    Closure(ClosureId, Substitution),
    /// Represents a foreign type declared in external blocks.
    ForeignType(ForeignDefId),
@@ -273,9 +273,9 @@ impl Ty {
 /// A list of substitutions for generic parameters.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct Substs(SmallVec<[Ty; 2]>);
+pub struct Substitution(SmallVec<[Ty; 2]>);
-impl TypeWalk for Substs {
+impl TypeWalk for Substitution {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        for t in self.0.iter() {
            t.walk(f);
@@ -293,29 +293,29 @@ impl TypeWalk for Substs {
    }
 }
-impl Substs {
+impl Substitution {
    pub fn interned(&self, _: &Interner) -> &[Ty] {
        &self.0
    }
-    pub fn empty() -> Substs {
+    pub fn empty() -> Substitution {
-        Substs(SmallVec::new())
+        Substitution(SmallVec::new())
    }
-    pub fn single(ty: Ty) -> Substs {
+    pub fn single(ty: Ty) -> Substitution {
-        Substs({
+        Substitution({
            let mut v = SmallVec::new();
            v.push(ty);
            v
        })
    }
-    pub fn prefix(&self, n: usize) -> Substs {
+    pub fn prefix(&self, n: usize) -> Substitution {
-        Substs(self.0[..std::cmp::min(self.0.len(), n)].into())
+        Substitution(self.0[..std::cmp::min(self.0.len(), n)].into())
    }
-    pub fn suffix(&self, n: usize) -> Substs {
+    pub fn suffix(&self, n: usize) -> Substitution {
-        Substs(self.0[self.0.len() - std::cmp::min(self.0.len(), n)..].into())
+        Substitution(self.0[self.0.len() - std::cmp::min(self.0.len(), n)..].into())
    }
    pub fn as_single(&self) -> &Ty {
@@ -326,15 +326,15 @@ impl Substs {
    }
    pub fn from_iter(_interner: &Interner, elements: impl IntoIterator<Item = Ty>) -> Self {
-        Substs(elements.into_iter().collect())
+        Substitution(elements.into_iter().collect())
    }
    /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
    pub(crate) fn type_params_for_generics(
        db: &dyn HirDatabase,
        generic_params: &Generics,
-    ) -> Substs {
+    ) -> Substitution {
-        Substs(
+        Substitution(
            generic_params
                .iter()
                .map(|(id, _)| TyKind::Placeholder(to_placeholder_idx(db, id)).intern(&Interner))
@@ -343,14 +343,14 @@ impl Substs {
    }
    /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`).
-    pub fn type_params(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substs {
+    pub fn type_params(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substitution {
        let params = generics(db.upcast(), def.into());
-        Substs::type_params_for_generics(db, &params)
+        Substitution::type_params_for_generics(db, &params)
    }
    /// Return Substs that replace each parameter by a bound variable.
-    pub(crate) fn bound_vars(generic_params: &Generics, debruijn: DebruijnIndex) -> Substs {
+    pub(crate) fn bound_vars(generic_params: &Generics, debruijn: DebruijnIndex) -> Substitution {
-        Substs(
+        Substitution(
            generic_params
                .iter()
                .enumerate()
@@ -363,11 +363,11 @@ impl Substs {
        let def = def.into();
        let params = generics(db.upcast(), def);
        let param_count = params.len();
-        Substs::builder(param_count)
+        Substitution::builder(param_count)
    }
    pub(crate) fn build_for_generics(generic_params: &Generics) -> SubstsBuilder {
-        Substs::builder(generic_params.len())
+        Substitution::builder(generic_params.len())
    }
    fn builder(param_count: usize) -> SubstsBuilder {
@@ -387,9 +387,9 @@ pub struct SubstsBuilder {
 }
 impl SubstsBuilder {
-    pub fn build(self) -> Substs {
+    pub fn build(self) -> Substitution {
        assert_eq!(self.vec.len(), self.param_count);
-        Substs(self.vec.into())
+        Substitution(self.vec.into())
    }
    pub fn push(mut self, ty: Ty) -> Self {
@@ -418,7 +418,7 @@ impl SubstsBuilder {
        self
    }
-    pub fn use_parent_substs(mut self, parent_substs: &Substs) -> Self {
+    pub fn use_parent_substs(mut self, parent_substs: &Substitution) -> Self {
        assert!(self.vec.is_empty());
        assert!(parent_substs.len() <= self.param_count);
        self.vec.extend(parent_substs.iter().cloned());
@@ -426,7 +426,7 @@ impl SubstsBuilder {
    }
 }
-impl Deref for Substs {
+impl Deref for Substitution {
    type Target = [Ty];
    fn deref(&self) -> &[Ty] {
@@ -466,13 +466,13 @@ impl<T: Clone> Binders<&T> {
 impl<T: TypeWalk> Binders<T> {
    /// Substitutes all variables.
-    pub fn subst(self, subst: &Substs) -> T {
+    pub fn subst(self, subst: &Substitution) -> T {
        assert_eq!(subst.len(), self.num_binders);
        self.value.subst_bound_vars(subst)
    }
    /// Substitutes just a prefix of the variables (shifting the rest).
-    pub fn subst_prefix(self, subst: &Substs) -> Binders<T> {
+    pub fn subst_prefix(self, subst: &Substitution) -> Binders<T> {
        assert!(subst.len() < self.num_binders);
        Binders::new(self.num_binders - subst.len(), self.value.subst_bound_vars(subst))
    }
@@ -498,7 +498,7 @@ impl<T: TypeWalk> TypeWalk for Binders<T> {
 pub struct TraitRef {
    /// FIXME name?
    pub trait_: TraitId,
-    pub substs: Substs,
+    pub substs: Substitution,
 }
 impl TraitRef {
@@ -618,7 +618,7 @@ impl CallableSig {
        }
    }
-    pub fn from_substs(substs: &Substs) -> CallableSig {
+    pub fn from_substs(substs: &Substitution) -> CallableSig {
        CallableSig { params_and_return: substs.iter().cloned().collect(), is_varargs: false }
    }
@@ -651,10 +651,10 @@ impl TypeWalk for CallableSig {
 impl Ty {
    pub fn unit() -> Self {
-        TyKind::Tuple(0, Substs::empty()).intern(&Interner)
+        TyKind::Tuple(0, Substitution::empty()).intern(&Interner)
    }
-    pub fn adt_ty(adt: hir_def::AdtId, substs: Substs) -> Ty {
+    pub fn adt_ty(adt: hir_def::AdtId, substs: Substitution) -> Ty {
        TyKind::Adt(AdtId(adt), substs).intern(&Interner)
    }
@@ -662,7 +662,7 @@ impl Ty {
        TyKind::Function(FnPointer {
            num_args: sig.params().len(),
            sig: FnSig { abi: (), safety: Safety::Safe, variadic: sig.is_varargs },
-            substs: Substs::from_iter(&Interner, sig.params_and_return.iter().cloned()),
+            substs: Substitution::from_iter(&Interner, sig.params_and_return.iter().cloned()),
        })
        .intern(&Interner)
    }
@@ -709,14 +709,14 @@ impl Ty {
        t
    }
-    pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substs)> {
+    pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)> {
        match self.interned(&Interner) {
            TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),
            _ => None,
        }
    }
-    pub fn as_tuple(&self) -> Option<&Substs> {
+    pub fn as_tuple(&self) -> Option<&Substitution> {
        match self.interned(&Interner) {
            TyKind::Tuple(_, substs) => Some(substs),
            _ => None,
@@ -828,7 +828,7 @@ impl Ty {
    /// Returns the type parameters of this type if it has some (i.e. is an ADT
    /// or function); so if `self` is `Option<u32>`, this returns the `u32`.
-    pub fn substs(&self) -> Option<&Substs> {
+    pub fn substs(&self) -> Option<&Substitution> {
        match self.interned(&Interner) {
            TyKind::Adt(_, substs)
            | TyKind::FnDef(_, substs)
@@ -841,7 +841,7 @@ impl Ty {
        }
    }
-    fn substs_mut(&mut self) -> Option<&mut Substs> {
+    fn substs_mut(&mut self) -> Option<&mut Substitution> {
        match self.interned_mut() {
            TyKind::Adt(_, substs)
            | TyKind::FnDef(_, substs)
@@ -869,7 +869,7 @@ impl Ty {
                            // So just provide the Future trait.
                            let impl_bound = GenericPredicate::Implemented(TraitRef {
                                trait_: future_trait,
-                                substs: Substs::empty(),
+                                substs: Substitution::empty(),
                            });
                            Some(vec![impl_bound])
                        } else {
@@ -992,7 +992,7 @@ pub trait TypeWalk {
    }
    /// Substitutes `TyKind::Bound` vars with the given substitution.
-    fn subst_bound_vars(self, substs: &Substs) -> Self
+    fn subst_bound_vars(self, substs: &Substitution) -> Self
    where
        Self: Sized,
    {
@@ -1000,7 +1000,7 @@ pub trait TypeWalk {
    }
    /// Substitutes `TyKind::Bound` vars with the given substitution.
-    fn subst_bound_vars_at_depth(mut self, substs: &Substs, depth: DebruijnIndex) -> Self
+    fn subst_bound_vars_at_depth(mut self, substs: &Substitution, depth: DebruijnIndex) -> Self
    where
        Self: Sized,
    {
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 6ab757bfc..462882b2b 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -35,7 +35,7 @@ use crate::{
    },
    AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate,
    ImplTraitId, OpaqueTy, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait,
-    ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
+    ReturnTypeImplTraits, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
 };
 #[derive(Debug)]
@@ -151,7 +151,7 @@ impl<'a> TyLoweringContext<'a> {
            TypeRef::Never => TyKind::Never.intern(&Interner),
            TypeRef::Tuple(inner) => {
                let inner_tys = inner.iter().map(|tr| self.lower_ty(tr));
-                TyKind::Tuple(inner_tys.len(), Substs::from_iter(&Interner, inner_tys))
+                TyKind::Tuple(inner_tys.len(), Substitution::from_iter(&Interner, inner_tys))
                    .intern(&Interner)
            }
            TypeRef::Path(path) => {
@@ -177,7 +177,7 @@ impl<'a> TyLoweringContext<'a> {
            }
            TypeRef::Placeholder => TyKind::Unknown.intern(&Interner),
            TypeRef::Fn(params, is_varargs) => {
-                let substs = Substs(params.iter().map(|tr| self.lower_ty(tr)).collect());
+                let substs = Substitution(params.iter().map(|tr| self.lower_ty(tr)).collect());
                TyKind::Function(FnPointer {
                    num_args: substs.len() - 1,
                    sig: FnSig { abi: (), safety: Safety::Safe, variadic: *is_varargs },
@@ -228,7 +228,7 @@ impl<'a> TyLoweringContext<'a> {
                        let impl_trait_id = ImplTraitId::ReturnTypeImplTrait(func, idx);
                        let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into();
                        let generics = generics(self.db.upcast(), func.into());
-                        let parameters = Substs::bound_vars(&generics, self.in_binders);
+                        let parameters = Substitution::bound_vars(&generics, self.in_binders);
                        TyKind::Alias(AliasTy::Opaque(OpaqueTy {
                            opaque_ty_id,
                            substitution: parameters,
@@ -398,10 +398,10 @@ impl<'a> TyLoweringContext<'a> {
                let generics = generics(self.db.upcast(), impl_id.into());
                let substs = match self.type_param_mode {
                    TypeParamLoweringMode::Placeholder => {
-                        Substs::type_params_for_generics(self.db, &generics)
+                        Substitution::type_params_for_generics(self.db, &generics)
                    }
                    TypeParamLoweringMode::Variable => {
-                        Substs::bound_vars(&generics, self.in_binders)
+                        Substitution::bound_vars(&generics, self.in_binders)
                    }
                };
                self.db.impl_self_ty(impl_id).subst(&substs)
@@ -410,10 +410,10 @@ impl<'a> TyLoweringContext<'a> {
                let generics = generics(self.db.upcast(), adt.into());
                let substs = match self.type_param_mode {
                    TypeParamLoweringMode::Placeholder => {
-                        Substs::type_params_for_generics(self.db, &generics)
+                        Substitution::type_params_for_generics(self.db, &generics)
                    }
                    TypeParamLoweringMode::Variable => {
-                        Substs::bound_vars(&generics, self.in_binders)
+                        Substitution::bound_vars(&generics, self.in_binders)
                    }
                };
                self.db.ty(adt.into()).subst(&substs)
@@ -464,7 +464,7 @@ impl<'a> TyLoweringContext<'a> {
                            TypeParamLoweringMode::Placeholder => {
                                // if we're lowering to placeholders, we have to put
                                // them in now
-                                let s = Substs::type_params(
+                                let s = Substitution::type_params(
                                    self.db,
                                    self.resolver.generic_def().expect(
                                        "there should be generics if there's a generic param",
@@ -522,7 +522,7 @@ impl<'a> TyLoweringContext<'a> {
        // special-case enum variants
        resolved: ValueTyDefId,
        infer_args: bool,
-    ) -> Substs {
+    ) -> Substitution {
        let last = path.segments().last().expect("path should have at least one segment");
        let (segment, generic_def) = match resolved {
            ValueTyDefId::FunctionId(it) => (last, Some(it.into())),
@@ -553,7 +553,7 @@ impl<'a> TyLoweringContext<'a> {
        segment: PathSegment<'_>,
        def_generic: Option<GenericDefId>,
        infer_args: bool,
-    ) -> Substs {
+    ) -> Substitution {
        let mut substs = Vec::new();
        let def_generics = def_generic.map(|def| generics(self.db.upcast(), def));
@@ -601,7 +601,7 @@ impl<'a> TyLoweringContext<'a> {
                for default_ty in defaults.iter().skip(substs.len()) {
                    // each default can depend on the previous parameters
-                    let substs_so_far = Substs(substs.clone().into());
+                    let substs_so_far = Substitution(substs.clone().into());
                    substs.push(default_ty.clone().subst(&substs_so_far));
                }
            }
@@ -614,7 +614,7 @@ impl<'a> TyLoweringContext<'a> {
        }
        assert_eq!(substs.len(), total_len);
-        Substs(substs.into())
+        Substitution(substs.into())
    }
    fn lower_trait_ref_from_path(
@@ -656,7 +656,11 @@ impl<'a> TyLoweringContext<'a> {
        self.lower_trait_ref_from_path(path, explicit_self_ty)
    }
-    fn trait_ref_substs_from_path(&self, segment: PathSegment<'_>, resolved: TraitId) -> Substs {
+    fn trait_ref_substs_from_path(
+        &self,
+        segment: PathSegment<'_>,
+        resolved: TraitId,
+    ) -> Substitution {
        self.substs_from_path_segment(segment, Some(resolved.into()), false)
    }
@@ -817,7 +821,7 @@ pub fn associated_type_shorthand_candidates<R>(
                {
                    let trait_ref = TraitRef {
                        trait_: trait_id,
-                        substs: Substs::bound_vars(&generics, DebruijnIndex::INNERMOST),
+                        substs: Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST),
                    };
                    traits_.push(trait_ref);
                }
@@ -945,7 +949,7 @@ pub(crate) fn trait_environment_query(
        // function default implementations (and hypothetical code
        // inside consts or type aliases)
        cov_mark::hit!(trait_self_implements_self);
-        let substs = Substs::type_params(db, trait_id);
+        let substs = Substitution::type_params(db, trait_id);
        let trait_ref = TraitRef { trait_: trait_id, substs };
        let pred = GenericPredicate::Implemented(trait_ref);
        let program_clause: chalk_ir::ProgramClause<Interner> =
@@ -1033,7 +1037,7 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
 /// function body.
 fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> {
    let generics = generics(db.upcast(), def.into());
-    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
+    let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
    Binders::new(
        substs.len(),
        TyKind::FnDef(CallableDefId::FunctionId(def).to_chalk(db), substs).intern(&Interner),
@@ -1078,7 +1082,7 @@ fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Binders<T
        return type_for_adt(db, def.into());
    }
    let generics = generics(db.upcast(), def.into());
-    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
+    let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
    Binders::new(
        substs.len(),
        TyKind::FnDef(CallableDefId::StructId(def).to_chalk(db), substs).intern(&Interner),
@@ -1105,7 +1109,7 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -
        return type_for_adt(db, def.parent.into());
    }
    let generics = generics(db.upcast(), def.parent.into());
-    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
+    let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
    Binders::new(
        substs.len(),
        TyKind::FnDef(CallableDefId::EnumVariantId(def).to_chalk(db), substs).intern(&Interner),
@@ -1114,7 +1118,7 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -
 fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
    let generics = generics(db.upcast(), adt.into());
-    let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
+    let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
    Binders::new(substs.len(), Ty::adt_ty(adt, substs))
 }
@@ -1126,7 +1130,7 @@ fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> {
    if db.type_alias_data(t).is_extern {
        Binders::new(0, TyKind::ForeignType(crate::to_foreign_def_id(t)).intern(&Interner))
    } else {
-        let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST);
+        let substs = Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST);
        let type_ref = &db.type_alias_data(t).type_ref;
        let inner = ctx.lower_ty(type_ref.as_ref().unwrap_or(&TypeRef::Error));
        Binders::new(substs.len(), inner)
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index be72c4a1c..943d3339b 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -21,7 +21,7 @@ use crate::{
    primitive::{self, FloatTy, IntTy, UintTy},
    utils::all_super_traits,
    AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, ForeignDefId, InEnvironment, Interner,
-    Scalar, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
+    Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
 };
 /// This is used as a key for indexing impls.
@@ -672,10 +672,10 @@ pub(crate) fn inherent_impl_substs(
    db: &dyn HirDatabase,
    impl_id: ImplId,
    self_ty: &Canonical<Ty>,
-) -> Option<Substs> {
+) -> Option<Substitution> {
    // 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 = Substs::build_for_def(db, impl_id)
+    let vars = Substitution::build_for_def(db, impl_id)
        .fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.kinds.len())
        .build();
    let self_ty_with_vars = db.impl_self_ty(impl_id).subst(&vars);
@@ -693,7 +693,7 @@ pub(crate) fn inherent_impl_substs(
 /// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
 /// num_vars_to_keep) by `TyKind::Unknown`.
-fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs {
+fn fallback_bound_vars(s: Substitution, num_vars_to_keep: usize) -> Substitution {
    s.fold_binders(
        &mut |ty, binders| {
            if let TyKind::BoundVar(bound) = ty.interned(&Interner) {
@@ -716,13 +716,13 @@ fn transform_receiver_ty(
    self_ty: &Canonical<Ty>,
 ) -> Option<Ty> {
    let substs = match function_id.lookup(db.upcast()).container {
-        AssocContainerId::TraitId(_) => Substs::build_for_def(db, function_id)
+        AssocContainerId::TraitId(_) => Substitution::build_for_def(db, function_id)
            .push(self_ty.value.clone())
            .fill_with_unknown()
            .build(),
        AssocContainerId::ImplId(impl_id) => {
            let impl_substs = inherent_impl_substs(db, impl_id, &self_ty)?;
-            Substs::build_for_def(db, function_id)
+            Substitution::build_for_def(db, function_id)
                .use_parent_substs(&impl_substs)
                .fill_with_unknown()
                .build()
@@ -768,7 +768,7 @@ fn generic_implements_goal(
    self_ty: Canonical<Ty>,
 ) -> Canonical<InEnvironment<super::Obligation>> {
    let mut kinds = self_ty.kinds.to_vec();
-    let substs = super::Substs::build_for_def(db, trait_)
+    let substs = super::Substitution::build_for_def(db, trait_)
        .push(self_ty.value)
        .fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len())
        .build();
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index fb3afaedc..af4f8bb11 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -216,6 +216,22 @@ fn expr_macro_expanded_in_various_places() {
 }
 #[test]
+fn expr_macro_expanded_in_stmts() {
+    check_infer(
+        r#"
+        macro_rules! id { ($($es:tt)*) => { $($es)* } }
+        fn foo() {
+            id! { let a = (); }
+        }
+        "#,
+        expect![[r#"
+            !0..8 'leta=();': ()
+            57..84 '{     ...); } }': ()
+        "#]],
+    );
+}
+#[test]
 fn infer_type_value_macro_having_same_name() {
    check_infer(
        r#"
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index a6a63c673..40eb1034e 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -8,7 +8,7 @@ use chalk_solve::{logging_db::LoggingRustIrDatabase, Solver};
 use hir_def::{lang_item::LangItemTarget, TraitId};
 use stdx::panic_context;
-use crate::{db::HirDatabase, DebruijnIndex, Substs};
+use crate::{db::HirDatabase, DebruijnIndex, Substitution};
 use super::{
    Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TyKind, TypeWalk,
@@ -252,7 +252,7 @@ fn solution_from_chalk(
 }
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct SolutionVariables(pub Canonical<Substs>);
+pub struct SolutionVariables(pub Canonical<Substitution>);
 #[derive(Clone, Debug, PartialEq, Eq)]
 /// A (possible) solution for a proposed goal.
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 232cf9cd0..bef6e7e9c 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -22,7 +22,7 @@ use crate::{
    to_assoc_type_id,
    utils::generics,
    BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId, GenericPredicate,
-    ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TyKind,
+    ProjectionPredicate, ProjectionTy, Substitution, TraitRef, Ty, TyKind,
 };
 use mapping::{
    convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue,
@@ -221,7 +221,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                    let impl_bound = GenericPredicate::Implemented(TraitRef {
                        trait_: future_trait,
                        // Self type as the first parameter.
-                        substs: Substs::single(
+                        substs: Substitution::single(
                            TyKind::BoundVar(BoundVar {
                                debruijn: DebruijnIndex::INNERMOST,
                                index: 0,
@@ -236,7 +236,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                        projection_ty: ProjectionTy {
                            associated_ty_id: to_assoc_type_id(future_output),
                            // Self type as the first parameter.
-                            substitution: Substs::single(
+                            substitution: Substitution::single(
                                TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
                                    .intern(&Interner),
                            ),
@@ -313,7 +313,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        _closure_id: chalk_ir::ClosureId<Interner>,
        _substs: &chalk_ir::Substitution<Interner>,
    ) -> chalk_ir::Substitution<Interner> {
-        Substs::empty().to_chalk(self.db)
+        Substitution::empty().to_chalk(self.db)
    }
    fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
@@ -392,7 +392,7 @@ pub(crate) fn associated_ty_data_query(
    // Lower bounds -- we could/should maybe move this to a separate query in `lower`
    let type_alias_data = db.type_alias_data(type_alias);
    let generic_params = generics(db.upcast(), type_alias.into());
-    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+    let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
    let ctx = crate::TyLoweringContext::new(db, &resolver)
        .with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable);
@@ -427,9 +427,9 @@ pub(crate) fn trait_datum_query(
    let trait_data = db.trait_data(trait_);
    debug!("trait {:?} = {:?}", trait_id, trait_data.name);
    let generic_params = generics(db.upcast(), trait_.into());
-    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+    let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let flags = rust_ir::TraitFlags {
-        auto: trait_data.auto,
+        auto: trait_data.is_auto,
        upstream: trait_.lookup(db.upcast()).container.krate() != krate,
        non_enumerable: true,
        coinductive: false, // only relevant for Chalk testing
@@ -496,7 +496,7 @@ pub(crate) fn struct_datum_query(
    let upstream = adt_id.module(db.upcast()).krate() != krate;
    let where_clauses = {
        let generic_params = generics(db.upcast(), adt_id.into());
-        let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+        let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
        convert_where_clauses(db, adt_id.into(), &bound_vars)
    };
    let flags = rust_ir::AdtFlags {
@@ -545,7 +545,7 @@ fn impl_def_datum(
    let impl_data = db.impl_data(impl_id);
    let generic_params = generics(db.upcast(), impl_id.into());
-    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+    let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let trait_ = trait_ref.trait_;
    let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
        rust_ir::ImplType::Local
@@ -635,7 +635,7 @@ pub(crate) fn fn_def_datum_query(
    let callable_def: CallableDefId = from_chalk(db, fn_def_id);
    let generic_params = generics(db.upcast(), callable_def.into());
    let sig = db.callable_item_signature(callable_def);
-    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
+    let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
    let bound = rust_ir::FnDefDatumBound {
        // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 6a8b6752e..524814f43 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -15,7 +15,7 @@ use crate::{
    primitive::UintTy,
    traits::{Canonical, Obligation},
    AliasTy, CallableDefId, FnPointer, GenericPredicate, InEnvironment, OpaqueTy,
-    ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitRef, Ty,
+    ProjectionPredicate, ProjectionTy, Scalar, Substitution, TraitRef, Ty,
 };
 use super::interner::*;
@@ -134,7 +134,7 @@ impl ToChalk for Ty {
                ..
            }) => {
                assert_eq!(num_binders, 0);
-                let substs: Substs = from_chalk(
+                let substs: Substitution = from_chalk(
                    db,
                    substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"),
                );
@@ -213,14 +213,17 @@ fn array_to_chalk(db: &dyn HirDatabase, ty: Ty) -> chalk_ir::Ty<Interner> {
    chalk_ir::TyKind::Array(arg, const_).intern(&Interner)
 }
-impl ToChalk for Substs {
+impl ToChalk for Substitution {
    type Chalk = chalk_ir::Substitution<Interner>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Substitution<Interner> {
        chalk_ir::Substitution::from_iter(&Interner, self.iter().map(|ty| ty.clone().to_chalk(db)))
    }
-    fn from_chalk(db: &dyn HirDatabase, parameters: chalk_ir::Substitution<Interner>) -> Substs {
+    fn from_chalk(
+        db: &dyn HirDatabase,
+        parameters: chalk_ir::Substitution<Interner>,
+    ) -> Substitution {
        let tys = parameters
            .iter(&Interner)
            .map(|p| match p.ty(&Interner) {
@@ -228,7 +231,7 @@ impl ToChalk for Substs {
                None => unimplemented!(),
            })
            .collect();
-        Substs(tys)
+        Substitution(tys)
    }
 }
@@ -489,7 +492,7 @@ where
 pub(super) fn convert_where_clauses(
    db: &dyn HirDatabase,
    def: GenericDefId,
-    substs: &Substs,
+    substs: &Substitution,
 ) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
    let generic_predicates = db.generic_predicates(def);
    let mut result = Vec::with_capacity(generic_predicates.len());
diff --git a/crates/ide/src/call_hierarchy.rs b/crates/ide/src/call_hierarchy.rs
index b848945d7..96021f677 100644
--- a/crates/ide/src/call_hierarchy.rs
+++ b/crates/ide/src/call_hierarchy.rs
@@ -53,10 +53,8 @@ pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Optio
        for (r_range, _) in references {
            let token = file.token_at_offset(r_range.start()).next()?;
            let token = sema.descend_into_macros(token);
-            let syntax = token.parent();
            // This target is the containing function
-            if let Some(nav) = syntax.ancestors().find_map(|node| {
+            if let Some(nav) = token.ancestors().find_map(|node| {
                let fn_ = ast::Fn::cast(node)?;
                let def = sema.to_def(&fn_)?;
                def.try_to_nav(sema.db)
@@ -77,12 +75,13 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
    let file = file.syntax();
    let token = file.token_at_offset(position.offset).next()?;
    let token = sema.descend_into_macros(token);
-    let syntax = token.parent();
    let mut calls = CallLocations::default();
-    syntax
+    token
-        .descendants()
+        .parent()
+        .into_iter()
+        .flat_map(|it| it.descendants())
        .filter_map(|node| FnCallNode::with_node_exact(&node))
        .filter_map(|call_node| {
            let name_ref = call_node.name_ref()?;
diff --git a/crates/ide/src/display.rs b/crates/ide/src/display.rs
index bae9e40df..71e97d6b4 100644
--- a/crates/ide/src/display.rs
+++ b/crates/ide/src/display.rs
@@ -2,9 +2,7 @@
 //! into types that may be used to render in a UI.
 pub(crate) mod navigation_target;
-mod short_label;
 pub(crate) use navigation_target::{ToNav, TryToNav};
-pub(crate) use short_label::ShortLabel;
-pub(crate) use syntax::display::{function_declaration, macro_label};
+pub(crate) use syntax::display::macro_label;
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 198243466..c086de163 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -3,9 +3,12 @@
 use std::fmt;
 use either::Either;
-use hir::{AssocItem, Documentation, FieldSource, HasAttrs, HasSource, InFile, ModuleSource};
+use hir::{
+    AssocItem, Documentation, FieldSource, HasAttrs, HasSource, HirDisplay, InFile, ModuleSource,
+    Semantics,
+};
 use ide_db::{
-    base_db::{FileId, FileRange, SourceDatabase},
+    base_db::{FileId, FileRange},
    symbol_index::FileSymbolKind,
    SymbolKind,
 };
@@ -17,8 +20,6 @@ use syntax::{
 use crate::FileSymbol;
-use super::short_label::ShortLabel;
 /// `NavigationTarget` represents and element in the editor's UI which you can
 /// click on to navigate to a particular piece of code.
 ///
@@ -98,7 +99,7 @@ impl NavigationTarget {
                SymbolKind::Module,
            );
            res.docs = module.attrs(db).docs();
-            res.description = src.value.short_label();
+            res.description = Some(module.display(db).to_string());
            return res;
        }
        module.to_nav(db)
@@ -251,8 +252,8 @@ impl ToNavFromAst for hir::Trait {
 impl<D> TryToNav for D
 where
-    D: HasSource + ToNavFromAst + Copy + HasAttrs,
+    D: HasSource + ToNavFromAst + Copy + HasAttrs + HirDisplay,
-    D::Ast: ast::NameOwner + ShortLabel,
+    D::Ast: ast::NameOwner,
 {
    fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
        let src = self.source(db)?;
@@ -262,7 +263,7 @@ where
            D::KIND,
        );
        res.docs = self.docs(db);
-        res.description = src.value.short_label();
+        res.description = Some(self.display(db).to_string());
        Some(res)
    }
 }
@@ -317,7 +318,7 @@ impl TryToNav for hir::Field {
                let mut res =
                    NavigationTarget::from_named(db, src.with_value(it), SymbolKind::Field);
                res.docs = self.docs(db);
-                res.description = it.short_label();
+                res.description = Some(self.display(db).to_string());
                res
            }
            FieldSource::Pos(it) => {
@@ -500,21 +501,22 @@ impl TryToNav for hir::ConstParam {
 ///
 /// e.g. `struct Name`, `enum Name`, `fn Name`
 pub(crate) fn description_from_symbol(db: &RootDatabase, symbol: &FileSymbol) -> Option<String> {
-    let parse = db.parse(symbol.file_id);
+    let sema = Semantics::new(db);
-    let node = symbol.ptr.to_node(parse.tree().syntax());
+    let parse = sema.parse(symbol.file_id);
+    let node = symbol.ptr.to_node(parse.syntax());
    match_ast! {
        match node {
-            ast::Fn(it) => it.short_label(),
+            ast::Fn(it) => sema.to_def(&it).map(|it| it.display(db).to_string()),
-            ast::Struct(it) => it.short_label(),
+            ast::Struct(it) => sema.to_def(&it).map(|it| it.display(db).to_string()),
-            ast::Enum(it) => it.short_label(),
+            ast::Enum(it) => sema.to_def(&it).map(|it| it.display(db).to_string()),
-            ast::Trait(it) => it.short_label(),
+            ast::Trait(it) => sema.to_def(&it).map(|it| it.display(db).to_string()),
-            ast::Module(it) => it.short_label(),
+            ast::Module(it) => sema.to_def(&it).map(|it| it.display(db).to_string()),
-            ast::TypeAlias(it) => it.short_label(),
+            ast::TypeAlias(it) => sema.to_def(&it).map(|it| it.display(db).to_string()),
-            ast::Const(it) => it.short_label(),
+            ast::Const(it) => sema.to_def(&it).map(|it| it.display(db).to_string()),
-            ast::Static(it) => it.short_label(),
+            ast::Static(it) => sema.to_def(&it).map(|it| it.display(db).to_string()),
-            ast::RecordField(it) => it.short_label(),
+            ast::RecordField(it) => sema.to_def(&it).map(|it| it.display(db).to_string()),
-            ast::Variant(it) => it.short_label(),
+            ast::Variant(it) => sema.to_def(&it).map(|it| it.display(db).to_string()),
            _ => None,
        }
    }
diff --git a/crates/ide/src/display/short_label.rs b/crates/ide/src/display/short_label.rs
deleted file mode 100644
index 2df9266b4..000000000
--- a/crates/ide/src/display/short_label.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-//! FIXME: write short doc here
-use stdx::format_to;
-use syntax::ast::{self, AstNode, NameOwner, VisibilityOwner};
-pub(crate) trait ShortLabel {
-    fn short_label(&self) -> Option<String>;
-}
-impl ShortLabel for ast::Fn {
-    fn short_label(&self) -> Option<String> {
-        Some(crate::display::function_declaration(self))
-    }
-}
-impl ShortLabel for ast::Struct {
-    fn short_label(&self) -> Option<String> {
-        short_label_from_node(self, "struct ")
-    }
-}
-impl ShortLabel for ast::Union {
-    fn short_label(&self) -> Option<String> {
-        short_label_from_node(self, "union ")
-    }
-}
-impl ShortLabel for ast::Enum {
-    fn short_label(&self) -> Option<String> {
-        short_label_from_node(self, "enum ")
-    }
-}
-impl ShortLabel for ast::Trait {
-    fn short_label(&self) -> Option<String> {
-        if self.unsafe_token().is_some() {
-            short_label_from_node(self, "unsafe trait ")
-        } else {
-            short_label_from_node(self, "trait ")
-        }
-    }
-}
-impl ShortLabel for ast::Module {
-    fn short_label(&self) -> Option<String> {
-        short_label_from_node(self, "mod ")
-    }
-}
-impl ShortLabel for ast::SourceFile {
-    fn short_label(&self) -> Option<String> {
-        None
-    }
-}
-impl ShortLabel for ast::BlockExpr {
-    fn short_label(&self) -> Option<String> {
-        None
-    }
-}
-impl ShortLabel for ast::TypeAlias {
-    fn short_label(&self) -> Option<String> {
-        let mut buf = short_label_from_node(self, "type ")?;
-        if let Some(type_ref) = self.ty() {
-            format_to!(buf, " = {}", type_ref.syntax());
-        }
-        Some(buf)
-    }
-}
-impl ShortLabel for ast::Const {
-    fn short_label(&self) -> Option<String> {
-        short_label_from_ty(self, self.ty(), "const ")
-    }
-}
-impl ShortLabel for ast::Static {
-    fn short_label(&self) -> Option<String> {
-        short_label_from_ty(self, self.ty(), "static ")
-    }
-}
-impl ShortLabel for ast::RecordField {
-    fn short_label(&self) -> Option<String> {
-        short_label_from_ty(self, self.ty(), "")
-    }
-}
-impl ShortLabel for ast::Variant {
-    fn short_label(&self) -> Option<String> {
-        Some(self.name()?.text().to_string())
-    }
-}
-impl ShortLabel for ast::ConstParam {
-    fn short_label(&self) -> Option<String> {
-        let mut buf = "const ".to_owned();
-        buf.push_str(self.name()?.text());
-        if let Some(type_ref) = self.ty() {
-            format_to!(buf, ": {}", type_ref.syntax());
-        }
-        Some(buf)
-    }
-}
-fn short_label_from_ty<T>(node: &T, ty: Option<ast::Type>, prefix: &str) -> Option<String>
-where
-    T: NameOwner + VisibilityOwner,
-{
-    let mut buf = short_label_from_node(node, prefix)?;
-    if let Some(type_ref) = ty {
-        format_to!(buf, ": {}", type_ref.syntax());
-    }
-    Some(buf)
-}
-fn short_label_from_node<T>(node: &T, label: &str) -> Option<String>
-where
-    T: NameOwner + VisibilityOwner,
-{
-    let mut buf = node.visibility().map(|v| format!("{} ", v.syntax())).unwrap_or_default();
-    buf.push_str(label);
-    buf.push_str(node.name()?.text());
-    Some(buf)
-}
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index 7bdd3cca3..461e11060 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -279,7 +279,7 @@ pub(crate) fn external_docs(
    let token = pick_best(file.token_at_offset(position.offset))?;
    let token = sema.descend_into_macros(token);
-    let node = token.parent();
+    let node = token.parent()?;
    let definition = match_ast! {
        match node {
            ast::NameRef(name_ref) => NameRefClass::classify(&sema, &name_ref).map(|d| d.referenced(sema.db)),
diff --git a/crates/ide/src/extend_selection.rs b/crates/ide/src/extend_selection.rs
index b540d04fe..e187243cb 100644
--- a/crates/ide/src/extend_selection.rs
+++ b/crates/ide/src/extend_selection.rs
@@ -88,7 +88,7 @@ fn try_extend_selection(
                    return Some(range);
                }
            }
-            token.parent()
+            token.parent()?
        }
        NodeOrToken::Node(node) => node,
    };
@@ -142,7 +142,8 @@ fn extend_tokens_from_range(
    let extended = {
        let fst_expanded = sema.descend_into_macros(first_token.clone());
        let lst_expanded = sema.descend_into_macros(last_token.clone());
-        let mut lca = algo::least_common_ancestor(&fst_expanded.parent(), &lst_expanded.parent())?;
+        let mut lca =
+            algo::least_common_ancestor(&fst_expanded.parent()?, &lst_expanded.parent()?)?;
        lca = shallowest_node(&lca);
        if lca.first_token() == Some(fst_expanded) && lca.last_token() == Some(lst_expanded) {
            lca = lca.parent()?;
@@ -151,9 +152,13 @@ fn extend_tokens_from_range(
    };
    // Compute parent node range
-    let validate = |token: &SyntaxToken| {
+    let validate = |token: &SyntaxToken| -> bool {
        let expanded = sema.descend_into_macros(token.clone());
-        algo::least_common_ancestor(&extended, &expanded.parent()).as_ref() == Some(&extended)
+        let parent = match expanded.parent() {
+            Some(it) => it,
+            None => return false,
+        };
+        algo::least_common_ancestor(&extended, &parent).as_ref() == Some(&extended)
    };
    // Find the first and last text range under expanded parent
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index e8f31e4b1..6986477a5 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -30,7 +30,7 @@ pub(crate) fn goto_definition(
    let file = sema.parse(position.file_id).syntax().clone();
    let original_token = pick_best(file.token_at_offset(position.offset))?;
    let token = sema.descend_into_macros(original_token.clone());
-    let parent = token.parent();
+    let parent = token.parent()?;
    if let Some(comment) = ast::Comment::cast(token) {
        let nav = def_for_doc_comment(&sema, position, &comment)?.try_to_nav(db)?;
        return Some(RangeInfo::new(original_token.text_range(), vec![nav]));
@@ -63,7 +63,7 @@ fn def_for_doc_comment(
    position: FilePosition,
    doc_comment: &ast::Comment,
 ) -> Option<hir::ModuleDef> {
-    let parent = doc_comment.syntax().parent();
+    let parent = doc_comment.syntax().parent()?;
    let (link, ns) = extract_positioned_link_from_comment(position, doc_comment)?;
    let def = doc_owner_to_def(sema, parent)?;
diff --git a/crates/ide/src/goto_type_definition.rs b/crates/ide/src/goto_type_definition.rs
index 369a59820..2d38cb112 100644
--- a/crates/ide/src/goto_type_definition.rs
+++ b/crates/ide/src/goto_type_definition.rs
@@ -22,7 +22,7 @@ pub(crate) fn goto_type_definition(
    let token: SyntaxToken = pick_best(file.syntax().token_at_offset(position.offset))?;
    let token: SyntaxToken = sema.descend_into_macros(token);
-    let (ty, node) = sema.ancestors_with_macros(token.parent()).find_map(|node| {
+    let (ty, node) = sema.token_ancestors_with_macros(token).find_map(|node| {
        let ty = match_ast! {
            match node {
                ast::Expr(it) => sema.type_of_expr(&it)?,
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index ea45086ce..325014622 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -1,7 +1,7 @@
 use either::Either;
 use hir::{
-    Adt, AsAssocItem, AssocItemContainer, FieldSource, GenericParam, HasAttrs, HasSource,
+    AsAssocItem, AssocItemContainer, GenericParam, HasAttrs, HasSource, HirDisplay, Module,
-    HirDisplay, Module, ModuleDef, ModuleSource, Semantics,
+    ModuleDef, Semantics,
 };
 use ide_db::{
    base_db::SourceDatabase,
@@ -14,7 +14,7 @@ use stdx::format_to;
 use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
 use crate::{
-    display::{macro_label, ShortLabel, TryToNav},
+    display::{macro_label, TryToNav},
    doc_links::{remove_links, rewrite_links},
    markdown_remove::remove_markdown,
    markup::Markup,
@@ -92,7 +92,7 @@ pub(crate) fn hover(
    let mut res = HoverResult::default();
-    let node = token.parent();
+    let node = token.parent()?;
    let definition = match_ast! {
        match node {
            // we don't use NameClass::referenced_or_defined here as we do not want to resolve
@@ -335,61 +335,34 @@ fn hover_for_definition(
            let label = macro_label(&it.source(db)?.value);
            from_def_source_labeled(db, it, Some(label), mod_path)
        }
-        Definition::Field(def) => {
+        Definition::Field(def) => from_hir_fmt(db, def, mod_path),
-            let src = def.source(db)?.value;
-            if let FieldSource::Named(it) = src {
-                from_def_source_labeled(db, def, it.short_label(), mod_path)
-            } else {
-                None
-            }
-        }
        Definition::ModuleDef(it) => match it {
-            ModuleDef::Module(it) => from_def_source_labeled(
+            ModuleDef::Module(it) => from_hir_fmt(db, it, mod_path),
-                db,
+            ModuleDef::Function(it) => from_hir_fmt(db, it, mod_path),
-                it,
+            ModuleDef::Adt(it) => from_hir_fmt(db, it, mod_path),
-                match it.definition_source(db).value {
+            ModuleDef::Variant(it) => from_hir_fmt(db, it, mod_path),
-                    ModuleSource::Module(it) => it.short_label(),
+            ModuleDef::Const(it) => from_hir_fmt(db, it, mod_path),
-                    ModuleSource::SourceFile(it) => it.short_label(),
+            ModuleDef::Static(it) => from_hir_fmt(db, it, mod_path),
-                    ModuleSource::BlockExpr(it) => it.short_label(),
+            ModuleDef::Trait(it) => from_hir_fmt(db, it, mod_path),
-                },
+            ModuleDef::TypeAlias(it) => from_hir_fmt(db, it, mod_path),
-                mod_path,
-            ),
-            ModuleDef::Function(it) => from_def_source(db, it, mod_path),
-            ModuleDef::Adt(Adt::Struct(it)) => from_def_source(db, it, mod_path),
-            ModuleDef::Adt(Adt::Union(it)) => from_def_source(db, it, mod_path),
-            ModuleDef::Adt(Adt::Enum(it)) => from_def_source(db, it, mod_path),
-            ModuleDef::Variant(it) => from_def_source(db, it, mod_path),
-            ModuleDef::Const(it) => from_def_source(db, it, mod_path),
-            ModuleDef::Static(it) => from_def_source(db, it, mod_path),
-            ModuleDef::Trait(it) => from_def_source(db, it, mod_path),
-            ModuleDef::TypeAlias(it) => from_def_source(db, it, mod_path),
            ModuleDef::BuiltinType(it) => famous_defs
                .and_then(|fd| hover_for_builtin(fd, it))
                .or_else(|| Some(Markup::fenced_block(&it.name()))),
        },
        Definition::Local(it) => hover_for_local(it, db),
        Definition::SelfType(impl_def) => {
-            impl_def.target_ty(db).as_adt().and_then(|adt| match adt {
+            impl_def.target_ty(db).as_adt().and_then(|adt| from_hir_fmt(db, adt, mod_path))
-                Adt::Struct(it) => from_def_source(db, it, mod_path),
-                Adt::Union(it) => from_def_source(db, it, mod_path),
-                Adt::Enum(it) => from_def_source(db, it, mod_path),
-            })
        }
+        Definition::GenericParam(it) => from_hir_fmt(db, it, None),
        Definition::Label(it) => Some(Markup::fenced_block(&it.name(db))),
-        Definition::GenericParam(it) => match it {
-            GenericParam::TypeParam(it) => Some(Markup::fenced_block(&it.display(db))),
-            GenericParam::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
-            GenericParam::ConstParam(it) => from_def_source(db, it, None),
-        },
    };
-    fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup>
+    fn from_hir_fmt<D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup>
    where
-        D: HasSource<Ast = A> + HasAttrs + Copy,
+        D: HasAttrs + HirDisplay,
-        A: ShortLabel,
    {
-        let short_label = def.source(db)?.value.short_label();
+        let label = def.display(db).to_string();
-        from_def_source_labeled(db, def, short_label, mod_path)
+        from_def_source_labeled(db, def, Some(label), mod_path)
    }
    fn from_def_source_labeled<D>(
@@ -438,7 +411,7 @@ fn hover_for_keyword(
    if !token.kind().is_keyword() {
        return None;
    }
-    let famous_defs = FamousDefs(&sema, sema.scope(&token.parent()).krate());
+    let famous_defs = FamousDefs(&sema, sema.scope(&token.parent()?).krate());
    // std exposes {}_keyword modules with docstrings on the root to document keywords
    let keyword_mod = format!("{}_keyword", token.text());
    let doc_owner = find_std_module(&famous_defs, &keyword_mod)?;
@@ -670,7 +643,9 @@ fn main() { let foo_test = fo$0o(); }
                ```
                ```rust
-                pub fn foo<'a, T: AsRef<str>>(b: &'a T) -> &'a str
+                pub fn foo<'a, T>(b: &'a T) -> &'a str
+                where
+                    T: AsRef<str>,
                ```
            "#]],
        );
@@ -878,7 +853,7 @@ fn main() { So$0me(12); }
                ```
                ```rust
-                Some
+                Some(T)
                ```
            "#]],
        );
@@ -944,7 +919,7 @@ fn main() {
                ```
                ```rust
-                Some
+                Some(T)
                ```
                ---
@@ -1441,13 +1416,14 @@ fn bar() { fo$0o(); }
                ```
            "#]],
        );
+        // Top level `pub(crate)` will be displayed as no visibility.
        check(
-            r#"pub(crate) async unsafe extern "C" fn foo$0() {}"#,
+            r#"mod m { pub(crate) async unsafe extern "C" fn foo$0() {} }"#,
            expect![[r#"
                *foo*
                ```rust
-                test
+                test::m
                ```
                ```rust
@@ -1489,11 +1465,18 @@ extern crate st$0d;
 //! abc123
            "#,
            expect![[r#"
-            *std*
+                *std*
-            Standard library for this test
+                ```rust
+                extern crate std
+                ```
+                ---
-            Printed?
+                Standard library for this test
-            abc123
+                Printed?
+                abc123
            "#]],
        );
        check(
@@ -1507,11 +1490,18 @@ extern crate std as ab$0c;
 //! abc123
            "#,
            expect![[r#"
-            *abc*
+                *abc*
-            Standard library for this test
+                ```rust
+                extern crate std
+                ```
-            Printed?
+                ---
-            abc123
+                Standard library for this test
+                Printed?
+                abc123
            "#]],
        );
    }
@@ -2021,7 +2011,7 @@ enum E {
                ```
                ```rust
-                V
+                V { field: i32 }
                ```
                ---
@@ -2417,7 +2407,7 @@ fn main() { let s$0t = S{ f1:Arg(0) }; }
                                    focus_range: 24..25,
                                    name: "S",
                                    kind: Struct,
-                                    description: "struct S",
+                                    description: "struct S<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -2463,7 +2453,7 @@ fn main() { let s$0t = S{ f1: S{ f1: Arg(0) } }; }
                                    focus_range: 24..25,
                                    name: "S",
                                    kind: Struct,
-                                    description: "struct S",
+                                    description: "struct S<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -2605,7 +2595,7 @@ fn main() { let s$0t = foo(); }
                                    focus_range: 6..9,
                                    name: "Foo",
                                    kind: Trait,
-                                    description: "trait Foo",
+                                    description: "trait Foo<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -2702,7 +2692,7 @@ fn main() { let s$0t = foo(); }
                                    focus_range: 6..9,
                                    name: "Foo",
                                    kind: Trait,
-                                    description: "trait Foo",
+                                    description: "trait Foo<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -2715,7 +2705,7 @@ fn main() { let s$0t = foo(); }
                                    focus_range: 22..25,
                                    name: "Bar",
                                    kind: Trait,
-                                    description: "trait Bar",
+                                    description: "trait Bar<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -2819,7 +2809,7 @@ fn foo(ar$0g: &impl Foo + Bar<S>) {}
                                    focus_range: 19..22,
                                    name: "Bar",
                                    kind: Trait,
-                                    description: "trait Bar",
+                                    description: "trait Bar<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -2916,7 +2906,7 @@ fn foo(ar$0g: &impl Foo<S>) {}
                                    focus_range: 6..9,
                                    name: "Foo",
                                    kind: Trait,
-                                    description: "trait Foo",
+                                    description: "trait Foo<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -2966,7 +2956,7 @@ fn main() { let s$0t = foo(); }
                                    focus_range: 49..50,
                                    name: "B",
                                    kind: Struct,
-                                    description: "struct B",
+                                    description: "struct B<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -3042,7 +3032,7 @@ fn foo(ar$0g: &dyn Foo<S>) {}
                                    focus_range: 6..9,
                                    name: "Foo",
                                    kind: Trait,
-                                    description: "trait Foo",
+                                    description: "trait Foo<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -3090,7 +3080,7 @@ fn foo(a$0rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                    focus_range: 6..15,
                                    name: "ImplTrait",
                                    kind: Trait,
-                                    description: "trait ImplTrait",
+                                    description: "trait ImplTrait<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -3103,7 +3093,7 @@ fn foo(a$0rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                    focus_range: 50..51,
                                    name: "B",
                                    kind: Struct,
-                                    description: "struct B",
+                                    description: "struct B<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -3116,7 +3106,7 @@ fn foo(a$0rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
                                    focus_range: 28..36,
                                    name: "DynTrait",
                                    kind: Trait,
-                                    description: "trait DynTrait",
+                                    description: "trait DynTrait<T>",
                                },
                            },
                            HoverGotoTypeData {
@@ -3582,6 +3572,17 @@ mod foo$0;
 "#,
            expect![[r#"
                *foo*
+                ```rust
+                test
+                ```
+                ```rust
+                mod foo
+                ```
+                ---
                For the horde!
            "#]],
        );
@@ -3606,7 +3607,7 @@ use foo::bar::{self$0};
                ```
                ```rust
-                pub mod bar
+                mod bar
                ```
                ---
@@ -3657,4 +3658,43 @@ cosnt _: &str$0 = ""; }"#;
            "#]],
        );
    }
+    #[test]
+    fn hover_macro_expanded_function() {
+        check(
+            r#"
+struct S<'a, T>(&'a T);
+trait Clone {}
+macro_rules! foo {
+    () => {
+        fn bar<'t, T: Clone + 't>(s: &mut S<'t, T>, t: u32) -> *mut u32 where
+            't: 't + 't,
+            for<'a> T: Clone + 'a
+        { 0 as _ }
+    };
+}
+foo!();
+fn main() {
+    bar$0;
+}
+"#,
+            expect![[r#"
+                *bar*
+                ```rust
+                test
+                ```
+                ```rust
+                fn bar<'t, T>(s: &mut S<'t, T>, t: u32) -> *mut u32
+                where
+                    T: Clone + 't,
+                    't: 't + 't,
+                    for<'a> T: Clone + 'a,
+                ```
+            "#]],
+        )
+    }
 }
diff --git a/crates/ide/src/join_lines.rs b/crates/ide/src/join_lines.rs
index d571ed559..4b25135cd 100644
--- a/crates/ide/src/join_lines.rs
+++ b/crates/ide/src/join_lines.rs
@@ -32,29 +32,35 @@ pub(crate) fn join_lines(file: &SourceFile, range: TextRange) -> TextEdit {
        range
    };
-    let node = match file.syntax().covering_element(range) {
-        NodeOrToken::Node(node) => node,
-        NodeOrToken::Token(token) => token.parent(),
-    };
    let mut edit = TextEdit::builder();
-    for token in node.descendants_with_tokens().filter_map(|it| it.into_token()) {
+    match file.syntax().covering_element(range) {
-        let range = match range.intersect(token.text_range()) {
+        NodeOrToken::Node(node) => {
-            Some(range) => range,
+            for token in node.descendants_with_tokens().filter_map(|it| it.into_token()) {
-            None => continue,
+                remove_newlines(&mut edit, &token, range)
-        } - token.text_range().start();
-        let text = token.text();
-        for (pos, _) in text[range].bytes().enumerate().filter(|&(_, b)| b == b'\n') {
-            let pos: TextSize = (pos as u32).into();
-            let offset = token.text_range().start() + range.start() + pos;
-            if !edit.invalidates_offset(offset) {
-                remove_newline(&mut edit, &token, offset);
            }
        }
-    }
+        NodeOrToken::Token(token) => remove_newlines(&mut edit, &token, range),
+    };
    edit.finish()
 }
+fn remove_newlines(edit: &mut TextEditBuilder, token: &SyntaxToken, range: TextRange) {
+    let intersection = match range.intersect(token.text_range()) {
+        Some(range) => range,
+        None => return,
+    };
+    let range = intersection - token.text_range().start();
+    let text = token.text();
+    for (pos, _) in text[range].bytes().enumerate().filter(|&(_, b)| b == b'\n') {
+        let pos: TextSize = (pos as u32).into();
+        let offset = token.text_range().start() + range.start() + pos;
+        if !edit.invalidates_offset(offset) {
+            remove_newline(edit, &token, offset);
+        }
+    }
+}
 fn remove_newline(edit: &mut TextEditBuilder, token: &SyntaxToken, offset: TextSize) {
    if token.kind() != WHITESPACE || token.text().bytes().filter(|&b| b == b'\n').count() != 1 {
        let mut string_open_quote = false;
@@ -148,7 +154,7 @@ fn has_comma_after(node: &SyntaxNode) -> bool {
 }
 fn join_single_expr_block(edit: &mut TextEditBuilder, token: &SyntaxToken) -> Option<()> {
-    let block_expr = ast::BlockExpr::cast(token.parent())?;
+    let block_expr = ast::BlockExpr::cast(token.parent()?)?;
    if !block_expr.is_standalone() {
        return None;
    }
@@ -170,7 +176,7 @@ fn join_single_expr_block(edit: &mut TextEditBuilder, token: &SyntaxToken) -> Op
 }
 fn join_single_use_tree(edit: &mut TextEditBuilder, token: &SyntaxToken) -> Option<()> {
-    let use_tree_list = ast::UseTreeList::cast(token.parent())?;
+    let use_tree_list = ast::UseTreeList::cast(token.parent()?)?;
    let (tree,) = use_tree_list.use_trees().collect_tuple()?;
    edit.replace(use_tree_list.syntax().text_range(), tree.syntax().text().to_string());
    Some(())
diff --git a/crates/ide/src/matching_brace.rs b/crates/ide/src/matching_brace.rs
index 000c412d9..4241a6dac 100644
--- a/crates/ide/src/matching_brace.rs
+++ b/crates/ide/src/matching_brace.rs
@@ -25,7 +25,7 @@ pub(crate) fn matching_brace(file: &SourceFile, offset: TextSize) -> Option<Text
            Some((node, idx))
        })
        .next()?;
-    let parent = brace_token.parent();
+    let parent = brace_token.parent()?;
    if brace_token.kind() == T![|] && !ast::ParamList::can_cast(parent.kind()) {
        cov_mark::hit!(pipes_not_braces);
        return None;
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index ec7c7686d..379674530 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -148,14 +148,15 @@ fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Optio
 fn get_name_of_item_declaration(syntax: &SyntaxNode, position: FilePosition) -> Option<ast::Name> {
    let token = syntax.token_at_offset(position.offset).right_biased()?;
+    let token_parent = token.parent()?;
    let kind = token.kind();
    if kind == T![;] {
-        ast::Struct::cast(token.parent())
+        ast::Struct::cast(token_parent)
            .filter(|struct_| struct_.field_list().is_none())
            .and_then(|struct_| struct_.name())
    } else if kind == T!['{'] {
        match_ast! {
-            match (token.parent()) {
+            match token_parent {
                ast::RecordFieldList(rfl) => match_ast! {
                    match (rfl.syntax().parent()?) {
                        ast::Variant(it) => it.name(),
@@ -169,7 +170,7 @@ fn get_name_of_item_declaration(syntax: &SyntaxNode, position: FilePosition) ->
            }
        }
    } else if kind == T!['('] {
-        let tfl = ast::TupleFieldList::cast(token.parent())?;
+        let tfl = ast::TupleFieldList::cast(token_parent)?;
        match_ast! {
            match (tfl.syntax().parent()?) {
                ast::Variant(it) => it.name(),
@@ -1270,4 +1271,27 @@ fn foo(_: bool) -> bo$0ol { true }
            "#]],
        );
    }
+    #[test]
+    fn test_transitive() {
+        check(
+            r#"
+//- /level3.rs new_source_root: crate:level3
+pub struct Fo$0o;
+//- /level2.rs new_source_root: crate:level2 deps:level3
+pub use level3::Foo;
+//- /level1.rs new_source_root: crate:level1 deps:level2
+pub use level2::Foo;
+//- /level0.rs new_source_root: crate:level0 deps:level1
+pub use level1::Foo;
+"#,
+            expect![[r#"
+                Foo Struct FileId(0) 0..15 11..14
+                FileId(1) 16..19
+                FileId(2) 16..19
+                FileId(3) 16..19
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 0c7a8fbf8..397e2126b 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -167,8 +167,7 @@ fn find_related_tests(
            let functions = refs.iter().filter_map(|(range, _)| {
                let token = file.token_at_offset(range.start()).next()?;
                let token = sema.descend_into_macros(token);
-                let syntax = token.parent();
+                token.ancestors().find_map(ast::Fn::cast)
-                syntax.ancestors().find_map(ast::Fn::cast)
            });
            for fn_def in functions {
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 9bed329d8..870146d24 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -64,7 +64,7 @@ pub(crate) fn highlight(
            Some(range) => {
                let node = match source_file.syntax().covering_element(range) {
                    NodeOrToken::Node(it) => it,
-                    NodeOrToken::Token(it) => it.parent(),
+                    NodeOrToken::Token(it) => it.parent().unwrap(),
                };
                (node, range)
            }
@@ -167,16 +167,19 @@ fn traverse(
        let element_to_highlight = if current_macro_call.is_some() && element.kind() != COMMENT {
            // Inside a macro -- expand it first
            let token = match element.clone().into_token() {
-                Some(it) if it.parent().kind() == TOKEN_TREE => it,
+                Some(it) if it.parent().map_or(false, |it| it.kind() == TOKEN_TREE) => it,
                _ => continue,
            };
            let token = sema.descend_into_macros(token.clone());
-            let parent = token.parent();
+            match token.parent() {
+                Some(parent) => {
-            // We only care Name and Name_ref
+                    // We only care Name and Name_ref
-            match (token.kind(), parent.kind()) {
+                    match (token.kind(), parent.kind()) {
-                (IDENT, NAME) | (IDENT, NAME_REF) => parent.into(),
+                        (IDENT, NAME) | (IDENT, NAME_REF) => parent.into(),
-                _ => token.into(),
+                        _ => token.into(),
+                    }
+                }
+                None => token.into(),
            }
        } else {
            element.clone()
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index 8c67a0863..e503abc93 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -28,7 +28,7 @@ pub(super) fn highlight_format_string(
 }
 fn is_format_string(string: &ast::String) -> Option<()> {
-    let parent = string.syntax().parent();
+    let parent = string.syntax().parent()?;
    let name = parent.parent().and_then(ast::MacroCall::cast)?.path()?.segment()?.name_ref()?;
    if !matches!(name.text(), "format_args" | "format_args_nl") {
diff --git a/crates/ide/src/syntax_tree.rs b/crates/ide/src/syntax_tree.rs
index f979ba434..8979de528 100644
--- a/crates/ide/src/syntax_tree.rs
+++ b/crates/ide/src/syntax_tree.rs
@@ -27,7 +27,7 @@ pub(crate) fn syntax_tree(
                if let Some(tree) = syntax_tree_for_string(&token, text_range) {
                    return tree;
                }
-                token.parent()
+                token.parent().unwrap()
            }
        };
diff --git a/crates/ide/src/typing.rs b/crates/ide/src/typing.rs
index a718faf63..e10b7d98e 100644
--- a/crates/ide/src/typing.rs
+++ b/crates/ide/src/typing.rs
@@ -108,7 +108,7 @@ fn on_dot_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
    };
    let current_indent_len = TextSize::of(current_indent);
-    let parent = whitespace.syntax().parent();
+    let parent = whitespace.syntax().parent()?;
    // Make sure dot is a part of call chain
    if !matches!(parent.kind(), FIELD_EXPR | METHOD_CALL_EXPR) {
        return None;
diff --git a/crates/ide_assists/src/handlers/add_turbo_fish.rs b/crates/ide_assists/src/handlers/add_turbo_fish.rs
index ee879c151..436767895 100644
--- a/crates/ide_assists/src/handlers/add_turbo_fish.rs
+++ b/crates/ide_assists/src/handlers/add_turbo_fish.rs
@@ -38,7 +38,7 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<(
        cov_mark::hit!(add_turbo_fish_one_fish_is_enough);
        return None;
    }
-    let name_ref = ast::NameRef::cast(ident.parent())?;
+    let name_ref = ast::NameRef::cast(ident.parent()?)?;
    let def = match NameRefClass::classify(&ctx.sema, &name_ref)? {
        NameRefClass::Definition(def) => def,
        NameRefClass::ExternCrate(_) | NameRefClass::FieldShorthand { .. } => return None,
diff --git a/crates/ide_assists/src/handlers/change_visibility.rs b/crates/ide_assists/src/handlers/change_visibility.rs
index ec99a5505..d7e39b2ae 100644
--- a/crates/ide_assists/src/handlers/change_visibility.rs
+++ b/crates/ide_assists/src/handlers/change_visibility.rs
@@ -41,7 +41,7 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    });
    let (offset, target) = if let Some(keyword) = item_keyword {
-        let parent = keyword.parent();
+        let parent = keyword.parent()?;
        let def_kws = vec![CONST, STATIC, TYPE_ALIAS, FN, MODULE, STRUCT, ENUM, TRAIT];
        // Parent is not a definition, can't add visibility
        if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
diff --git a/crates/ide_assists/src/handlers/expand_glob_import.rs b/crates/ide_assists/src/handlers/expand_glob_import.rs
index 5fe617ba4..5b540df5c 100644
--- a/crates/ide_assists/src/handlers/expand_glob_import.rs
+++ b/crates/ide_assists/src/handlers/expand_glob_import.rs
@@ -48,7 +48,7 @@ pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Opti
        _ => return None,
    };
-    let current_scope = ctx.sema.scope(&star.parent());
+    let current_scope = ctx.sema.scope(&star.parent()?);
    let current_module = current_scope.module()?;
    let refs_in_target = find_refs_in_mod(ctx, target_module, Some(current_module))?;
diff --git a/crates/ide_assists/src/handlers/extract_function.rs b/crates/ide_assists/src/handlers/extract_function.rs
index dd4501709..5fdc8bf38 100644
--- a/crates/ide_assists/src/handlers/extract_function.rs
+++ b/crates/ide_assists/src/handlers/extract_function.rs
@@ -16,7 +16,6 @@ use syntax::{
        edit::{AstNodeEdit, IndentLevel},
        AstNode,
    },
-    SyntaxElement,
    SyntaxKind::{self, BLOCK_EXPR, BREAK_EXPR, COMMENT, PATH_EXPR, RETURN_EXPR},
    SyntaxNode, SyntaxToken, TextRange, TextSize, TokenAtOffset, WalkEvent, T,
 };
@@ -62,7 +61,10 @@ pub(crate) fn extract_function(acc: &mut Assists, ctx: &AssistContext) -> Option
        return None;
    }
-    let node = element_to_node(node);
+    let node = match node {
+        syntax::NodeOrToken::Node(n) => n,
+        syntax::NodeOrToken::Token(t) => t.parent()?,
+    };
    let body = extraction_target(&node, ctx.frange.range)?;
@@ -560,14 +562,6 @@ impl HasTokenAtOffset for FunctionBody {
    }
 }
-/// node or token's parent
-fn element_to_node(node: SyntaxElement) -> SyntaxNode {
-    match node {
-        syntax::NodeOrToken::Node(n) => n,
-        syntax::NodeOrToken::Token(t) => t.parent(),
-    }
-}
 /// Try to guess what user wants to extract
 ///
 /// We have basically have two cases:
@@ -1246,7 +1240,7 @@ fn make_body(
            })
        }
        FlowHandler::If { .. } => {
-            let lit_false = ast::Literal::cast(make::tokens::literal("false").parent()).unwrap();
+            let lit_false = make::expr_literal("false");
            with_tail_expr(block, lit_false.into())
        }
        FlowHandler::IfOption { .. } => {
@@ -1420,9 +1414,7 @@ fn update_external_control_flow(handler: &FlowHandler, syntax: &SyntaxNode) -> S
 fn make_rewritten_flow(handler: &FlowHandler, arg_expr: Option<ast::Expr>) -> Option<ast::Expr> {
    let value = match handler {
        FlowHandler::None | FlowHandler::Try { .. } => return None,
-        FlowHandler::If { .. } => {
+        FlowHandler::If { .. } => make::expr_literal("true").into(),
-            ast::Literal::cast(make::tokens::literal("true").parent()).unwrap().into()
-        }
        FlowHandler::IfOption { .. } => {
            let expr = arg_expr.unwrap_or_else(|| make::expr_tuple(Vec::new()));
            let args = make::arg_list(iter::once(expr));
diff --git a/crates/ide_assists/src/handlers/flip_trait_bound.rs b/crates/ide_assists/src/handlers/flip_trait_bound.rs
index d419d263e..a868aa43d 100644
--- a/crates/ide_assists/src/handlers/flip_trait_bound.rs
+++ b/crates/ide_assists/src/handlers/flip_trait_bound.rs
@@ -23,7 +23,7 @@ pub(crate) fn flip_trait_bound(acc: &mut Assists, ctx: &AssistContext) -> Option
    let plus = ctx.find_token_syntax_at_offset(T![+])?;
    // Make sure we're in a `TypeBoundList`
-    if ast::TypeBoundList::cast(plus.parent()).is_none() {
+    if ast::TypeBoundList::cast(plus.parent()?).is_none() {
        return None;
    }
diff --git a/crates/ide_assists/src/handlers/generate_is_empty_from_len.rs b/crates/ide_assists/src/handlers/generate_is_empty_from_len.rs
index aa7072f25..b8834d283 100644
--- a/crates/ide_assists/src/handlers/generate_is_empty_from_len.rs
+++ b/crates/ide_assists/src/handlers/generate_is_empty_from_len.rs
@@ -1,7 +1,7 @@
 use hir::{known, HasSource, Name};
 use syntax::{
    ast::{self, NameOwner},
-    AstNode, TextRange,
+    AstNode,
 };
 use crate::{
@@ -51,12 +51,19 @@ pub(crate) fn generate_is_empty_from_len(acc: &mut Assists, ctx: &AssistContext)
    }
    let impl_ = fn_node.syntax().ancestors().find_map(ast::Impl::cast)?;
+    let len_fn = get_impl_method(ctx, &impl_, &known::len)?;
+    if !len_fn.ret_type(ctx.sema.db).is_usize() {
+        cov_mark::hit!(len_fn_different_return_type);
+        return None;
+    }
    if get_impl_method(ctx, &impl_, &known::is_empty).is_some() {
        cov_mark::hit!(is_empty_already_implemented);
        return None;
    }
-    let range = get_text_range_of_len_function(ctx, &impl_)?;
+    let node = len_fn.source(ctx.sema.db)?;
+    let range = node.syntax().value.text_range();
    acc.add(
        AssistId("generate_is_empty_from_len", AssistKind::Generate),
@@ -89,13 +96,6 @@ fn get_impl_method(
    ty.iterate_method_candidates(db, krate, &traits_in_scope, Some(fn_name), |_, func| Some(func))
 }
-fn get_text_range_of_len_function(ctx: &AssistContext, impl_: &ast::Impl) -> Option<TextRange> {
-    let db = ctx.sema.db;
-    let func = get_impl_method(ctx, impl_, &known::len)?;
-    let node = func.source(db)?;
-    Some(node.syntax().value.text_range())
-}
 #[cfg(test)]
 mod tests {
    use crate::tests::{check_assist, check_assist_not_applicable};
@@ -158,6 +158,23 @@ impl MyStruct {
    }
    #[test]
+    fn len_fn_different_return_type() {
+        cov_mark::check!(len_fn_different_return_type);
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+impl MyStruct {
+    p$0ub fn len(&self) -> u32 {
+        self.data.len()
+    }
+}
+"#,
+        );
+    }
+    #[test]
    fn generate_is_empty() {
        check_assist(
            generate_is_empty_from_len,
diff --git a/crates/ide_assists/src/handlers/invert_if.rs b/crates/ide_assists/src/handlers/invert_if.rs
index b131dc205..53612ec3f 100644
--- a/crates/ide_assists/src/handlers/invert_if.rs
+++ b/crates/ide_assists/src/handlers/invert_if.rs
@@ -30,7 +30,7 @@ use crate::{
 pub(crate) fn invert_if(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let if_keyword = ctx.find_token_syntax_at_offset(T![if])?;
-    let expr = ast::IfExpr::cast(if_keyword.parent())?;
+    let expr = ast::IfExpr::cast(if_keyword.parent()?)?;
    let if_range = if_keyword.text_range();
    let cursor_in_range = if_range.contains_range(ctx.frange.range);
    if !cursor_in_range {
diff --git a/crates/ide_assists/src/handlers/move_bounds.rs b/crates/ide_assists/src/handlers/move_bounds.rs
index cf260c6f8..9ad0c9816 100644
--- a/crates/ide_assists/src/handlers/move_bounds.rs
+++ b/crates/ide_assists/src/handlers/move_bounds.rs
@@ -1,8 +1,6 @@
 use syntax::{
-    ast::{self, edit::AstNodeEdit, make, AstNode, NameOwner, TypeBoundsOwner},
+    ast::{self, edit_in_place::GenericParamsOwnerEdit, make, AstNode, NameOwner, TypeBoundsOwner},
    match_ast,
-    SyntaxKind::*,
-    T,
 };
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -23,7 +21,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let type_param_list = ctx.find_node_at_offset::<ast::GenericParamList>()?;
+    let type_param_list = ctx.find_node_at_offset::<ast::GenericParamList>()?.clone_for_update();
    let mut type_params = type_param_list.type_params();
    if type_params.all(|p| p.type_bound_list().is_none()) {
@@ -31,23 +29,7 @@ pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext
    }
    let parent = type_param_list.syntax().parent()?;
-    if parent.children_with_tokens().any(|it| it.kind() == WHERE_CLAUSE) {
+    let original_parent_range = parent.text_range();
-        return None;
-    }
-    let anchor = match_ast! {
-        match parent {
-            ast::Fn(it) => it.body()?.syntax().clone().into(),
-            ast::Trait(it) => it.assoc_item_list()?.syntax().clone().into(),
-            ast::Impl(it) => it.assoc_item_list()?.syntax().clone().into(),
-            ast::Enum(it) => it.variant_list()?.syntax().clone().into(),
-            ast::Struct(it) => {
-                it.syntax().children_with_tokens()
-                    .find(|it| it.kind() == RECORD_FIELD_LIST || it.kind() == T![;])?
-            },
-            _ => return None
-        }
-    };
    let target = type_param_list.syntax().text_range();
    acc.add(
@@ -55,29 +37,27 @@ pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext
        "Move to where clause",
        target,
        |edit| {
-            let new_params = type_param_list
+            let where_clause: ast::WhereClause = match_ast! {
-                .type_params()
+                match parent {
-                .filter(|it| it.type_bound_list().is_some())
+                    ast::Fn(it) => it.get_or_create_where_clause(),
-                .map(|type_param| {
+                    ast::Trait(it) => it.get_or_create_where_clause(),
-                    let without_bounds = type_param.remove_bounds();
+                    ast::Impl(it) => it.get_or_create_where_clause(),
-                    (type_param, without_bounds)
+                    ast::Enum(it) => it.get_or_create_where_clause(),
-                });
+                    ast::Struct(it) => it.get_or_create_where_clause(),
+                    _ => return,
-            let new_type_param_list = type_param_list.replace_descendants(new_params);
+                }
-            edit.replace_ast(type_param_list.clone(), new_type_param_list);
-            let where_clause = {
-                let predicates = type_param_list.type_params().filter_map(build_predicate);
-                make::where_clause(predicates)
            };
-            let to_insert = match anchor.prev_sibling_or_token() {
+            for type_param in type_param_list.type_params() {
-                Some(ref elem) if elem.kind() == WHITESPACE => {
+                if let Some(tbl) = type_param.type_bound_list() {
-                    format!("{} ", where_clause.syntax())
+                    if let Some(predicate) = build_predicate(type_param.clone()) {
+                        where_clause.add_predicate(predicate.clone_for_update())
+                    }
+                    tbl.remove()
                }
-                _ => format!(" {}", where_clause.syntax()),
+            }
-            };
-            edit.insert(anchor.text_range().start(), to_insert);
+            edit.replace(original_parent_range, parent.to_string())
        },
    )
 }
@@ -102,12 +82,8 @@ mod tests {
    fn move_bounds_to_where_clause_fn() {
        check_assist(
            move_bounds_to_where_clause,
-            r#"
+            r#"fn foo<T: u32, $0F: FnOnce(T) -> T>() {}"#,
-            fn foo<T: u32, $0F: FnOnce(T) -> T>() {}
+            r#"fn foo<T, F>() where T: u32, F: FnOnce(T) -> T {}"#,
-            "#,
-            r#"
-            fn foo<T, F>() where T: u32, F: FnOnce(T) -> T {}
-            "#,
        );
    }
@@ -115,12 +91,8 @@ mod tests {
    fn move_bounds_to_where_clause_impl() {
        check_assist(
            move_bounds_to_where_clause,
-            r#"
+            r#"impl<U: u32, $0T> A<U, T> {}"#,
-            impl<U: u32, $0T> A<U, T> {}
+            r#"impl<U, T> A<U, T> where U: u32 {}"#,
-            "#,
-            r#"
-            impl<U, T> A<U, T> where U: u32 {}
-            "#,
        );
    }
@@ -128,12 +100,8 @@ mod tests {
    fn move_bounds_to_where_clause_struct() {
        check_assist(
            move_bounds_to_where_clause,
-            r#"
+            r#"struct A<$0T: Iterator<Item = u32>> {}"#,
-            struct A<$0T: Iterator<Item = u32>> {}
+            r#"struct A<T> where T: Iterator<Item = u32> {}"#,
-            "#,
-            r#"
-            struct A<T> where T: Iterator<Item = u32> {}
-            "#,
        );
    }
@@ -141,12 +109,8 @@ mod tests {
    fn move_bounds_to_where_clause_tuple_struct() {
        check_assist(
            move_bounds_to_where_clause,
-            r#"
+            r#"struct Pair<$0T: u32>(T, T);"#,
-            struct Pair<$0T: u32>(T, T);
+            r#"struct Pair<T>(T, T) where T: u32;"#,
-            "#,
-            r#"
-            struct Pair<T>(T, T) where T: u32;
-            "#,
        );
    }
 }
diff --git a/crates/ide_assists/src/handlers/split_import.rs b/crates/ide_assists/src/handlers/split_import.rs
index 9319a4267..446f30544 100644
--- a/crates/ide_assists/src/handlers/split_import.rs
+++ b/crates/ide_assists/src/handlers/split_import.rs
@@ -17,7 +17,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // ```
 pub(crate) fn split_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let colon_colon = ctx.find_token_syntax_at_offset(T![::])?;
-    let path = ast::Path::cast(colon_colon.parent())?.qualifier()?;
+    let path = ast::Path::cast(colon_colon.parent()?)?.qualifier()?;
    let top_path = successors(Some(path.clone()), |it| it.parent_path()).last()?;
    let use_tree = top_path.syntax().ancestors().find_map(ast::UseTree::cast)?;
diff --git a/crates/ide_assists/src/handlers/unwrap_block.rs b/crates/ide_assists/src/handlers/unwrap_block.rs
index ed6f6177d..440639322 100644
--- a/crates/ide_assists/src/handlers/unwrap_block.rs
+++ b/crates/ide_assists/src/handlers/unwrap_block.rs
@@ -30,7 +30,7 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let assist_label = "Unwrap block";
    let l_curly_token = ctx.find_token_syntax_at_offset(T!['{'])?;
-    let mut block = ast::BlockExpr::cast(l_curly_token.parent())?;
+    let mut block = ast::BlockExpr::cast(l_curly_token.parent()?)?;
    let target = block.syntax().text_range();
    let mut parent = block.syntax().parent()?;
    if ast::MatchArm::can_cast(parent.kind()) {
diff --git a/crates/ide_completion/src/completions/dot.rs b/crates/ide_completion/src/completions/dot.rs
index 5ee9a9f07..cec2d0c3a 100644
--- a/crates/ide_completion/src/completions/dot.rs
+++ b/crates/ide_completion/src/completions/dot.rs
@@ -81,7 +81,7 @@ fn foo(s: S) { s.$0 }
 "#,
            expect![[r#"
                fd foo   u32
-                me bar() -> ()
+                me bar() fn(&self)
            "#]],
        );
    }
@@ -97,7 +97,7 @@ impl S {
 "#,
            expect![[r#"
                fd the_field (u32,)
-                me foo()     -> ()
+                me foo()     fn(self)
            "#]],
        )
    }
@@ -113,7 +113,7 @@ impl A {
 "#,
            expect![[r#"
                fd the_field (u32, i32)
-                me foo()     -> ()
+                me foo()     fn(&self)
            "#]],
        )
    }
@@ -163,7 +163,7 @@ mod m {
 fn foo(a: A) { a.$0 }
 "#,
            expect![[r#"
-                me the_method() -> ()
+                me the_method() fn(&self)
            "#]],
        );
    }
@@ -196,7 +196,7 @@ impl A<i32> {
 fn foo(a: A<u32>) { a.$0 }
 "#,
            expect![[r#"
-                me the_method() -> ()
+                me the_method() fn(&self)
            "#]],
        )
    }
@@ -211,7 +211,7 @@ impl Trait for A {}
 fn foo(a: A) { a.$0 }
 "#,
            expect![[r#"
-                me the_method() -> ()
+                me the_method() fn(&self)
            "#]],
        );
    }
@@ -226,7 +226,7 @@ impl<T> Trait for T {}
 fn foo(a: &A) { a.$0 }
 ",
            expect![[r#"
-                me the_method() -> ()
+                me the_method() fn(&self)
            "#]],
        );
    }
@@ -244,7 +244,7 @@ impl Trait for A {}
 fn foo(a: A) { a.$0 }
 ",
            expect![[r#"
-                me the_method() -> ()
+                me the_method() fn(&self)
            "#]],
        );
    }
@@ -298,7 +298,7 @@ impl T {
 }
 "#,
            expect![[r#"
-                me blah() -> ()
+                me blah() fn(&self)
            "#]],
        );
    }
@@ -407,7 +407,7 @@ fn foo() {
 }
 "#,
            expect![[r#"
-                me the_method() -> ()
+                me the_method() fn(&self)
            "#]],
        );
    }
@@ -422,7 +422,7 @@ macro_rules! make_s { () => { S }; }
 fn main() { make_s!().f$0; }
 "#,
            expect![[r#"
-                me foo() -> ()
+                me foo() fn(&self)
            "#]],
        )
    }
@@ -450,7 +450,7 @@ mod foo {
 }
        "#,
            expect![[r#"
-                me private() -> ()
+                me private() fn(&self)
            "#]],
        );
    }
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index 391a11c91..08df2df3f 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -402,7 +402,7 @@ fn main() {
        check(
            fixture,
            expect![[r#"
-                fn weird_function() (dep::test_mod::TestTrait) -> ()
+                fn weird_function() (dep::test_mod::TestTrait) fn()
            "#]],
        );
@@ -495,7 +495,7 @@ fn main() {
        check(
            fixture,
            expect![[r#"
-                me random_method() (dep::test_mod::TestTrait) -> ()
+                me random_method() (dep::test_mod::TestTrait) fn(&self)
            "#]],
        );
@@ -665,7 +665,7 @@ fn main() {
 }
        "#,
            expect![[r#"
-                me random_method() (dep::test_mod::TestTrait) -> () DEPRECATED
+                me random_method() (dep::test_mod::TestTrait) fn(&self) DEPRECATED
            "#]],
        );
@@ -696,7 +696,7 @@ fn main() {
 "#,
            expect![[r#"
                ct SPECIAL_CONST (dep::test_mod::TestTrait) DEPRECATED
-                fn weird_function() (dep::test_mod::TestTrait) -> () DEPRECATED
+                fn weird_function() (dep::test_mod::TestTrait) fn() DEPRECATED
            "#]],
        );
    }
diff --git a/crates/ide_completion/src/completions/fn_param.rs b/crates/ide_completion/src/completions/fn_param.rs
index 0243dce56..0ea558489 100644
--- a/crates/ide_completion/src/completions/fn_param.rs
+++ b/crates/ide_completion/src/completions/fn_param.rs
@@ -33,7 +33,7 @@ pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
        });
    };
-    for node in ctx.token.parent().ancestors() {
+    for node in ctx.token.ancestors() {
        match_ast! {
            match node {
                ast::SourceFile(it) => it.items().filter_map(|item| match item {
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index df74b739e..105ff6013 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -359,8 +359,8 @@ impl S {
 fn foo() { let _ = S::$0 }
 "#,
            expect![[r#"
-                fn a()  -> ()
+                fn a()  fn()
-                me b(…) -> ()
+                me b(…) fn(&self)
                ct C    const C: i32 = 42;
                ta T    type T = i32;
            "#]],
@@ -387,7 +387,7 @@ mod m {
 fn foo() { let _ = S::$0 }
 "#,
            expect![[r#"
-                fn public_method() -> ()
+                fn public_method() fn()
                ct PUBLIC_CONST    pub(crate) const PUBLIC_CONST: u32 = 1;
                ta PublicType      pub(crate) type PublicType = u32;
            "#]],
@@ -404,7 +404,7 @@ impl E { fn m() { } }
 fn foo() { let _ = E::$0 }
        "#,
            expect![[r#"
-                fn m() -> ()
+                fn m() fn()
            "#]],
        );
    }
@@ -419,7 +419,7 @@ impl U { fn m() { } }
 fn foo() { let _ = U::$0 }
 "#,
            expect![[r#"
-                fn m() -> ()
+                fn m() fn()
            "#]],
        );
    }
@@ -449,7 +449,7 @@ trait Trait { fn m(); }
 fn foo() { let _ = Trait::$0 }
 "#,
            expect![[r#"
-                fn m() -> ()
+                fn m() fn()
            "#]],
        );
    }
@@ -466,7 +466,7 @@ impl Trait for S {}
 fn foo() { let _ = S::$0 }
 "#,
            expect![[r#"
-                fn m() -> ()
+                fn m() fn()
            "#]],
        );
    }
@@ -483,7 +483,7 @@ impl Trait for S {}
 fn foo() { let _ = <S as Trait>::$0 }
 "#,
            expect![[r#"
-                fn m() -> ()
+                fn m() fn()
            "#]],
        );
    }
@@ -512,11 +512,11 @@ fn foo<T: Sub>() { T::$0 }
                ta SubTy        type SubTy;
                ta Ty           type Ty;
                ct C2           const C2: ();
-                fn subfunc()    -> ()
+                fn subfunc()    fn()
-                me submethod(…) -> ()
+                me submethod(…) fn(&self)
                ct CONST        const CONST: u8;
-                fn func()       -> ()
+                fn func()       fn()
-                me method(…)    -> ()
+                me method(…)    fn(&self)
            "#]],
        );
    }
@@ -552,11 +552,11 @@ impl<T> Sub for Wrap<T> {
                ta SubTy        type SubTy;
                ta Ty           type Ty;
                ct CONST        const CONST: u8 = 0;
-                fn func()       -> ()
+                fn func()       fn()
-                me method(…)    -> ()
+                me method(…)    fn(&self)
                ct C2           const C2: () = ();
-                fn subfunc()    -> ()
+                fn subfunc()    fn()
-                me submethod(…) -> ()
+                me submethod(…) fn(&self)
            "#]],
        );
    }
@@ -573,8 +573,8 @@ impl T { fn bar() {} }
 fn main() { T::$0; }
 "#,
            expect![[r#"
-                fn foo() -> ()
+                fn foo() fn()
-                fn bar() -> ()
+                fn bar() fn()
            "#]],
        );
    }
@@ -589,7 +589,7 @@ macro_rules! foo { () => {} }
 fn main() { let _ = crate::$0 }
        "#,
            expect![[r##"
-                fn main()  -> ()
+                fn main()  fn()
                ma foo!(…) #[macro_export] macro_rules! foo
            "##]],
        );
@@ -633,7 +633,7 @@ mod p {
 "#,
            expect![[r#"
                ct RIGHT_CONST
-                fn right_fn()  -> ()
+                fn right_fn()  fn()
                st RightType
            "#]],
        );
@@ -680,8 +680,8 @@ fn main() { m!(self::f$0); }
 fn foo() {}
 "#,
            expect![[r#"
-                fn main() -> ()
+                fn main() fn()
-                fn foo()  -> ()
+                fn foo()  fn()
            "#]],
        );
    }
@@ -699,7 +699,7 @@ mod m {
 "#,
            expect![[r#"
                md z
-                fn z() -> ()
+                fn z() fn()
            "#]],
        );
    }
@@ -719,7 +719,7 @@ fn foo() {
 }
 "#,
            expect![[r#"
-                fn new() -> HashMap<K, V, RandomState>
+                fn new() fn() -> HashMap<K, V, RandomState>
            "#]],
        );
    }
@@ -752,8 +752,8 @@ fn main() {
 }
 "#,
            expect![[r#"
-                fn main() -> ()
+                fn main() fn()
-                fn foo(…) -> ()
+                fn foo(…) fn(i32, i32)
            "#]],
        );
    }
@@ -776,7 +776,7 @@ impl Foo {
            expect![[r#"
                ev Bar    ()
                ev Baz    ()
-                me foo(…) -> ()
+                me foo(…) fn(self)
            "#]],
        );
    }
@@ -800,7 +800,7 @@ impl u8 {
 "#,
            expect![[r#"
                ct MAX     pub const MAX: Self = 255;
-                me func(…) -> ()
+                me func(…) fn(self)
            "#]],
        );
    }
diff --git a/crates/ide_completion/src/completions/trait_impl.rs b/crates/ide_completion/src/completions/trait_impl.rs
index 5a7361f8e..a26fe7c6c 100644
--- a/crates/ide_completion/src/completions/trait_impl.rs
+++ b/crates/ide_completion/src/completions/trait_impl.rs
@@ -82,13 +82,14 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
 fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, SyntaxNode, Impl)> {
    let mut token = ctx.token.clone();
-    // For keywork without name like `impl .. { fn $0 }`, the current position is inside
+    // For keyword without name like `impl .. { fn $0 }`, the current position is inside
    // the whitespace token, which is outside `FN` syntax node.
    // We need to follow the previous token in this case.
    if token.kind() == SyntaxKind::WHITESPACE {
        token = token.prev_token()?;
    }
+    let parent_kind = token.parent().map_or(SyntaxKind::EOF, |it| it.kind());
    let impl_item_offset = match token.kind() {
        // `impl .. { const $0 }`
        // ERROR      0
@@ -102,14 +103,14 @@ fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, Synt
        // FN/TYPE_ALIAS/CONST  1
        //  NAME                0
        //    IDENT             <- *
-        SyntaxKind::IDENT if token.parent().kind() == SyntaxKind::NAME => 1,
+        SyntaxKind::IDENT if parent_kind == SyntaxKind::NAME => 1,
        // `impl .. { foo$0 }`
        // MACRO_CALL       3
        //  PATH            2
        //    PATH_SEGMENT  1
        //      NAME_REF    0
        //        IDENT     <- *
-        SyntaxKind::IDENT if token.parent().kind() == SyntaxKind::NAME_REF => 3,
+        SyntaxKind::IDENT if parent_kind == SyntaxKind::NAME_REF => 3,
        _ => return None,
    };
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index 5ef80f6a7..1b8b063e7 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -135,7 +135,7 @@ fn quux(x: i32) {
            expect![[r#"
                lc y       i32
                lc x       i32
-                fn quux(…) -> ()
+                fn quux(…) fn(i32)
            "#]],
        );
    }
@@ -157,7 +157,7 @@ fn quux() {
            expect![[r#"
                lc b      i32
                lc a
-                fn quux() -> ()
+                fn quux() fn()
            "#]],
        );
    }
@@ -172,7 +172,7 @@ fn quux() {
 "#,
            expect![[r#"
                lc x
-                fn quux() -> ()
+                fn quux() fn()
            "#]],
        );
    }
@@ -203,14 +203,14 @@ fn main() {
            r#"fn quux<T>() { $0 }"#,
            expect![[r#"
                tp T
-                fn quux() -> ()
+                fn quux() fn()
            "#]],
        );
        check(
            r#"fn quux<const C: usize>() { $0 }"#,
            expect![[r#"
                cp C
-                fn quux() -> ()
+                fn quux() fn()
            "#]],
        );
    }
@@ -221,7 +221,7 @@ fn main() {
        check(
            r#"fn quux<'a>() { $0 }"#,
            expect![[r#"
-                fn quux() -> ()
+                fn quux() fn()
            "#]],
        );
    }
@@ -259,7 +259,7 @@ fn quux() { $0 }
 "#,
            expect![[r#"
                st S
-                fn quux() -> ()
+                fn quux() fn()
                en E
            "#]],
        );
@@ -312,7 +312,7 @@ mod m {
 }
 "#,
            expect![[r#"
-                fn quux() -> ()
+                fn quux() fn()
                st Bar
            "#]],
        );
@@ -327,7 +327,7 @@ fn x() -> $0
 "#,
            expect![[r#"
                st Foo
-                fn x() -> ()
+                fn x() fn()
            "#]],
        );
    }
@@ -348,7 +348,7 @@ fn foo() {
            expect![[r#"
                lc bar   i32
                lc bar   i32
-                fn foo() -> ()
+                fn foo() fn()
            "#]],
        );
    }
@@ -378,7 +378,7 @@ use prelude::*;
 mod prelude { struct Option; }
 "#,
            expect![[r#"
-                fn foo()  -> ()
+                fn foo()  fn()
                md std
                st Option
            "#]],
@@ -408,7 +408,7 @@ mod macros {
 }
 "#,
            expect![[r##"
-                fn f()        -> ()
+                fn f()        fn()
                ma concat!(…) #[macro_export] macro_rules! concat
                md std
            "##]],
@@ -435,7 +435,7 @@ use prelude::*;
 mod prelude { struct String; }
 "#,
            expect![[r#"
-                fn foo()  -> ()
+                fn foo()  fn()
                md std
                md core
                st String
@@ -466,7 +466,7 @@ fn main() { let v = $0 }
            expect![[r##"
                md m1
                ma baz!(…) #[macro_export] macro_rules! baz
-                fn main()  -> ()
+                fn main()  fn()
                md m2
                ma bar!(…) macro_rules! bar
                ma foo!(…) macro_rules! foo
@@ -482,7 +482,7 @@ macro_rules! foo { () => {} }
 fn foo() { $0 }
 "#,
            expect![[r#"
-                fn foo()   -> ()
+                fn foo()   fn()
                ma foo!(…) macro_rules! foo
            "#]],
        );
@@ -496,7 +496,7 @@ macro_rules! foo { () => {} }
 fn main() { let x: $0 }
 "#,
            expect![[r#"
-                fn main()  -> ()
+                fn main()  fn()
                ma foo!(…) macro_rules! foo
            "#]],
        );
@@ -510,7 +510,7 @@ macro_rules! foo { () => {} }
 fn main() { $0 }
 "#,
            expect![[r#"
-                fn main()  -> ()
+                fn main()  fn()
                ma foo!(…) macro_rules! foo
            "#]],
        );
@@ -526,8 +526,8 @@ fn main() {
 }
 "#,
            expect![[r#"
-                fn frobnicate() -> ()
+                fn frobnicate() fn()
-                fn main()       -> ()
+                fn main()       fn()
            "#]],
        );
    }
@@ -545,7 +545,7 @@ fn quux(x: i32) {
            expect![[r#"
                lc y       i32
                lc x       i32
-                fn quux(…) -> ()
+                fn quux(…) fn(i32)
                ma m!(…)   macro_rules! m
            "#]],
        );
@@ -564,7 +564,7 @@ fn quux(x: i32) {
            expect![[r#"
                lc y       i32
                lc x       i32
-                fn quux(…) -> ()
+                fn quux(…) fn(i32)
                ma m!(…)   macro_rules! m
            "#]],
        );
@@ -583,7 +583,7 @@ fn quux(x: i32) {
            expect![[r#"
                lc y       i32
                lc x       i32
-                fn quux(…) -> ()
+                fn quux(…) fn(i32)
                ma m!(…)   macro_rules! m
            "#]],
        );
@@ -598,7 +598,7 @@ use spam::Quux;
 fn main() { $0 }
 "#,
            expect![[r#"
-                fn main() -> ()
+                fn main() fn()
                ?? Quux
            "#]],
        );
@@ -616,7 +616,7 @@ fn main() { let foo: Foo = Q$0 }
                ev Foo::Baz  ()
                ev Foo::Quux ()
                en Foo
-                fn main()    -> ()
+                fn main()    fn()
            "#]],
        )
    }
@@ -631,7 +631,7 @@ fn f() -> m::E { V$0 }
            expect![[r#"
                ev m::E::V ()
                md m
-                fn f()     -> E
+                fn f()     fn() -> E
            "#]],
        )
    }
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index e6cc6329c..6d57da06a 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -120,7 +120,7 @@ impl<'a> CompletionContext<'a> {
        let original_token =
            original_file.syntax().token_at_offset(position.offset).left_biased()?;
        let token = sema.descend_into_macros(original_token.clone());
-        let scope = sema.scope_at_offset(&token.parent(), position.offset);
+        let scope = sema.scope_at_offset(&token, position.offset);
        let mut locals = vec![];
        scope.process_all_names(&mut |name, scope| {
            if let ScopeDef::Local(local) = scope {
@@ -281,7 +281,7 @@ impl<'a> CompletionContext<'a> {
    fn fill_impl_def(&mut self) {
        self.impl_def = self
            .sema
-            .ancestors_with_macros(self.token.parent())
+            .token_ancestors_with_macros(self.token.clone())
            .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
            .find_map(ast::Impl::cast);
    }
@@ -293,7 +293,10 @@ impl<'a> CompletionContext<'a> {
        offset: TextSize,
    ) {
        let expected = {
-            let mut node = self.token.parent();
+            let mut node = match self.token.parent() {
+                Some(it) => it,
+                None => return,
+            };
            loop {
                let ret = match_ast! {
                    match node {
@@ -310,7 +313,7 @@ impl<'a> CompletionContext<'a> {
                            (ty, name)
                        },
-                        ast::ArgList(it) => {
+                        ast::ArgList(_it) => {
                            cov_mark::hit!(expected_type_fn_param_with_leading_char);
                            cov_mark::hit!(expected_type_fn_param_without_leading_char);
                            ActiveParameter::at_token(
@@ -319,7 +322,7 @@ impl<'a> CompletionContext<'a> {
                            ).map(|ap| (Some(ap.ty), Some(ap.name)))
                            .unwrap_or((None, None))
                        },
-                        ast::RecordExprFieldList(it) => {
+                        ast::RecordExprFieldList(_it) => {
                            cov_mark::hit!(expected_type_struct_field_without_leading_char);
                            self.token.prev_sibling_or_token()
                                .and_then(|se| se.into_node())
@@ -355,7 +358,7 @@ impl<'a> CompletionContext<'a> {
                            (ty, None)
                        },
-                        ast::Fn(it) => {
+                        ast::Fn(_it) => {
                            cov_mark::hit!(expected_type_fn_ret_with_leading_char);
                            cov_mark::hit!(expected_type_fn_ret_without_leading_char);
                            let ty = self.token.ancestors()
@@ -474,17 +477,17 @@ impl<'a> CompletionContext<'a> {
        }
        self.use_item_syntax =
-            self.sema.ancestors_with_macros(self.token.parent()).find_map(ast::Use::cast);
+            self.sema.token_ancestors_with_macros(self.token.clone()).find_map(ast::Use::cast);
        self.function_syntax = self
            .sema
-            .ancestors_with_macros(self.token.parent())
+            .token_ancestors_with_macros(self.token.clone())
            .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
            .find_map(ast::Fn::cast);
        self.record_field_syntax = self
            .sema
-            .ancestors_with_macros(self.token.parent())
+            .token_ancestors_with_macros(self.token.clone())
            .take_while(|it| {
                it.kind() != SOURCE_FILE && it.kind() != MODULE && it.kind() != CALL_EXPR
            })
diff --git a/crates/ide_completion/src/lib.rs b/crates/ide_completion/src/lib.rs
index 263554ecf..5b7ad38d5 100644
--- a/crates/ide_completion/src/lib.rs
+++ b/crates/ide_completion/src/lib.rs
@@ -230,7 +230,7 @@ fn foo() {
    bar.fo$0;
 }
 "#,
-            DetailAndDocumentation { detail: "-> ()", documentation: "Do the foo" },
+            DetailAndDocumentation { detail: "fn(&self)", documentation: "Do the foo" },
        );
    }
@@ -255,7 +255,7 @@ fn foo() {
    bar.fo$0;
 }
 "#,
-            DetailAndDocumentation { detail: "-> ()", documentation: " Do the foo" },
+            DetailAndDocumentation { detail: "fn(&self)", documentation: " Do the foo" },
        );
    }
@@ -273,7 +273,7 @@ fn bar() {
    for c in fo$0
 }
 "#,
-            DetailAndDocumentation { detail: "-> &str", documentation: "Do the foo" },
+            DetailAndDocumentation { detail: "fn() -> &str", documentation: "Do the foo" },
        );
    }
 }
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index f3ce91dd1..cf5ef07b7 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -184,11 +184,7 @@ fn test_has_impl_as_prev_sibling() {
 }
 pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
-    let leaf = match element {
+    for node in element.ancestors() {
-        NodeOrToken::Node(node) => node,
-        NodeOrToken::Token(token) => token.parent(),
-    };
-    for node in leaf.ancestors() {
        if node.kind() == FN || node.kind() == CLOSURE_EXPR {
            break;
        }
@@ -201,7 +197,7 @@ pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
            }
        };
        if let Some(body) = loop_body {
-            if body.syntax().text_range().contains_range(leaf.text_range()) {
+            if body.syntax().text_range().contains_range(element.text_range()) {
                return true;
            }
        }
@@ -235,12 +231,8 @@ fn previous_sibling_or_ancestor_sibling(element: SyntaxElement) -> Option<Syntax
        Some(sibling)
    } else {
        // if not trying to find first ancestor which has such a sibling
-        let node = match element {
+        let range = element.text_range();
-            NodeOrToken::Node(node) => node,
+        let top_node = element.ancestors().take_while(|it| it.text_range() == range).last()?;
-            NodeOrToken::Token(token) => token.parent(),
-        };
-        let range = node.text_range();
-        let top_node = node.ancestors().take_while(|it| it.text_range() == range).last()?;
        let prev_sibling_node = top_node.ancestors().find(|it| {
            non_trivia_sibling(NodeOrToken::Node(it.to_owned()), Direction::Prev).is_some()
        })?;
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index 2514dda7c..4e4923e0d 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -10,10 +10,8 @@ pub(crate) mod type_alias;
 mod builder_ext;
-use base_db::Upcast;
 use hir::{
-    db::HirDatabase, AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability,
+    AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type,
-    ScopeDef, Type,
 };
 use ide_db::{
    helpers::{item_name, SnippetCap},
@@ -22,8 +20,8 @@ use ide_db::{
 use syntax::TextRange;
 use crate::{
-    item::{CompletionRelevance, ImportEdit},
+    item::ImportEdit, CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
-    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
+    CompletionRelevance,
 };
 use crate::render::{enum_variant::render_variant, function::render_fn, macro_::render_macro};
@@ -144,7 +142,15 @@ impl<'a> Render<'a> {
            .set_documentation(field.docs(self.ctx.db()))
            .set_deprecated(is_deprecated);
-        item.set_relevance(compute_relevance(&self.ctx, &ty, &name.to_string()));
+        item.set_relevance(CompletionRelevance {
+            exact_type_match: compute_exact_type_match(self.ctx.completion, ty),
+            exact_name_match: compute_exact_name_match(self.ctx.completion, name.to_string()),
+            ..CompletionRelevance::default()
+        });
+        if let Some(ref_match) = compute_ref_match(self.ctx.completion, ty) {
+            item.ref_match(ref_match);
+        }
        item.build()
    }
@@ -234,31 +240,18 @@ impl<'a> Render<'a> {
            if !ty.is_unknown() {
                item.detail(ty.display(self.ctx.db()).to_string());
            }
-        };
-        if let ScopeDef::Local(local) = resolution {
+            item.set_relevance(CompletionRelevance {
-            let ty = local.ty(self.ctx.db());
+                exact_type_match: compute_exact_type_match(self.ctx.completion, &ty),
+                exact_name_match: compute_exact_name_match(self.ctx.completion, local_name.clone()),
+                is_local: true,
+                ..CompletionRelevance::default()
+            });
-            let mut relevance = compute_relevance(&self.ctx, &ty, &local_name);
+            if let Some(ref_match) = compute_ref_match(self.ctx.completion, &ty) {
-            relevance.is_local = true;
+                item.ref_match(ref_match);
-            item.set_relevance(relevance);
-            if let Some(expected_type) = self.ctx.completion.expected_type.as_ref() {
-                if &ty != expected_type {
-                    if let Some(ty_without_ref) = expected_type.remove_ref() {
-                        if relevance_type_match(self.ctx.db().upcast(), &ty, &ty_without_ref) {
-                            cov_mark::hit!(suggest_ref);
-                            let mutability = if expected_type.is_mutable_reference() {
-                                Mutability::Mut
-                            } else {
-                                Mutability::Shared
-                            };
-                            item.ref_match(mutability);
-                        }
-                    }
-                }
            }
-        }
+        };
        // Add `<>` for generic types
        if self.ctx.completion.is_path_type
@@ -313,17 +306,38 @@ impl<'a> Render<'a> {
    }
 }
-fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> CompletionRelevance {
+fn compute_exact_type_match(ctx: &CompletionContext, completion_ty: &hir::Type) -> bool {
-    let mut res = CompletionRelevance::default();
+    match ctx.expected_type.as_ref() {
+        Some(expected_type) => {
+            // We don't ever consider unit type to be an exact type match, since
+            // nearly always this is not meaningful to the user.
+            completion_ty == expected_type && !expected_type.is_unit()
+        }
+        None => false,
+    }
+}
-    res.exact_type_match = Some(ty) == ctx.completion.expected_type.as_ref();
+fn compute_exact_name_match(ctx: &CompletionContext, completion_name: impl Into<String>) -> bool {
-    res.exact_name_match = Some(name) == ctx.completion.expected_name.as_deref();
+    let completion_name = completion_name.into();
-    res
+    Some(&completion_name) == ctx.expected_name.as_ref()
 }
-fn relevance_type_match(db: &dyn HirDatabase, ty: &Type, expected_type: &Type) -> bool {
+fn compute_ref_match(ctx: &CompletionContext, completion_ty: &hir::Type) -> Option<Mutability> {
-    ty == expected_type || ty.autoderef(db).any(|deref_ty| &deref_ty == expected_type)
+    let expected_type = ctx.expected_type.as_ref()?;
+    if completion_ty != expected_type {
+        let expected_type_without_ref = expected_type.remove_ref()?;
+        if completion_ty.autoderef(ctx.db).any(|deref_ty| deref_ty == expected_type_without_ref) {
+            cov_mark::hit!(suggest_ref);
+            let mutability = if expected_type.is_mutable_reference() {
+                Mutability::Mut
+            } else {
+                Mutability::Shared
+            };
+            return Some(mutability);
+        };
+    }
+    None
 }
 #[cfg(test)]
@@ -432,6 +446,44 @@ fn main() { Foo::Fo$0 }
    }
    #[test]
+    fn fn_detail_includes_args_and_return_type() {
+        check(
+            r#"
+fn foo<T>(a: u32, b: u32, t: T) -> (u32, T) { (a, t) }
+fn main() { fo$0 }
+"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "foo(…)",
+                        source_range: 68..70,
+                        delete: 68..70,
+                        insert: "foo(${1:a}, ${2:b}, ${3:t})$0",
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        lookup: "foo",
+                        detail: "fn(u32, u32, T) -> (u32, T)",
+                        trigger_call_info: true,
+                    },
+                    CompletionItem {
+                        label: "main()",
+                        source_range: 68..70,
+                        delete: 68..70,
+                        insert: "main()$0",
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        lookup: "main",
+                        detail: "fn()",
+                    },
+                ]
+            "#]],
+        );
+    }
+    #[test]
    fn enum_detail_just_parentheses_for_unit() {
        check(
            r#"
@@ -477,6 +529,11 @@ fn main() { let _: m::Spam = S$0 }
                        ),
                        lookup: "Spam::Bar",
                        detail: "(i32)",
+                        relevance: CompletionRelevance {
+                            exact_name_match: false,
+                            exact_type_match: true,
+                            is_local: false,
+                        },
                        trigger_call_info: true,
                    },
                    CompletionItem {
@@ -498,6 +555,11 @@ fn main() { let _: m::Spam = S$0 }
                        ),
                        lookup: "Spam::Foo",
                        detail: "()",
+                        relevance: CompletionRelevance {
+                            exact_name_match: false,
+                            exact_type_match: true,
+                            is_local: false,
+                        },
                    },
                    CompletionItem {
                        label: "main()",
@@ -508,7 +570,7 @@ fn main() { let _: m::Spam = S$0 }
                            Function,
                        ),
                        lookup: "main",
-                        detail: "-> ()",
+                        detail: "fn()",
                    },
                ]
            "#]],
@@ -537,7 +599,7 @@ fn main() { som$0 }
                            Function,
                        ),
                        lookup: "main",
-                        detail: "-> ()",
+                        detail: "fn()",
                    },
                    CompletionItem {
                        label: "something_deprecated()",
@@ -548,7 +610,7 @@ fn main() { som$0 }
                            Function,
                        ),
                        lookup: "something_deprecated",
-                        detail: "-> ()",
+                        detail: "fn()",
                        deprecated: true,
                    },
                    CompletionItem {
@@ -560,7 +622,7 @@ fn main() { som$0 }
                            Function,
                        ),
                        lookup: "something_else_deprecated",
-                        detail: "-> ()",
+                        detail: "fn()",
                        deprecated: true,
                    },
                ]
@@ -611,7 +673,7 @@ impl S {
                        insert: "bar()$0",
                        kind: Method,
                        lookup: "bar",
-                        detail: "-> ()",
+                        detail: "fn(self)",
                        documentation: Documentation(
                            "Method docs",
                        ),
@@ -711,7 +773,7 @@ fn foo(s: S) { s.$0 }
                        insert: "the_method()$0",
                        kind: Method,
                        lookup: "the_method",
-                        detail: "-> ()",
+                        detail: "fn(&self)",
                    },
                ]
            "#]],
@@ -1019,7 +1081,7 @@ fn main() {
                            Function,
                        ),
                        lookup: "foo",
-                        detail: "-> ()",
+                        detail: "fn(&mut S)",
                        trigger_call_info: true,
                    },
                    CompletionItem {
@@ -1031,7 +1093,7 @@ fn main() {
                            Function,
                        ),
                        lookup: "main",
-                        detail: "-> ()",
+                        detail: "fn()",
                    },
                    CompletionItem {
                        label: "s",
@@ -1169,4 +1231,86 @@ fn foo(bar: u32) {
            "#]],
        );
    }
+    #[test]
+    fn enum_owned() {
+        check_relevance(
+            r#"
+enum Foo { A, B }
+fn foo() {
+    bar($0);
+}
+fn bar(t: Foo) {}
+"#,
+            expect![[r#"
+                ev Foo::A [type]
+                ev Foo::B [type]
+                en Foo []
+                fn bar(…) []
+                fn foo() []
+            "#]],
+        );
+    }
+    #[test]
+    fn enum_ref() {
+        check_relevance(
+            r#"
+enum Foo { A, B }
+fn foo() {
+    bar($0);
+}
+fn bar(t: &Foo) {}
+"#,
+            expect![[r#"
+                ev Foo::A []
+                ev &Foo::A [type]
+                ev Foo::B []
+                ev &Foo::B [type]
+                en Foo []
+                fn bar(…) []
+                fn foo() []
+            "#]],
+        );
+    }
+    #[test]
+    fn suggest_deref_fn_ret() {
+        check_relevance(
+            r#"
+#[lang = "deref"]
+trait Deref {
+    type Target;
+    fn deref(&self) -> &Self::Target;
+}
+struct S;
+struct T(S);
+impl Deref for T {
+    type Target = S;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+fn foo(s: &S) {}
+fn bar() -> T {}
+fn main() {
+    foo($0);
+}
+            "#,
+            expect![[r#"
+                tt Deref []
+                fn bar() []
+                fn &bar() [type]
+                fn foo(…) []
+                st T []
+                st S []
+                fn main() []
+            "#]],
+        )
+    }
 }
diff --git a/crates/ide_completion/src/render/enum_variant.rs b/crates/ide_completion/src/render/enum_variant.rs
index e8cfcc0c7..374247b05 100644
--- a/crates/ide_completion/src/render/enum_variant.rs
+++ b/crates/ide_completion/src/render/enum_variant.rs
@@ -6,7 +6,8 @@ use itertools::Itertools;
 use crate::{
    item::{CompletionItem, CompletionKind, ImportEdit},
-    render::{builder_ext::Params, RenderContext},
+    render::{builder_ext::Params, compute_exact_type_match, compute_ref_match, RenderContext},
+    CompletionRelevance,
 };
 pub(crate) fn render_variant<'a>(
@@ -74,6 +75,16 @@ impl<'a> EnumRender<'a> {
            item.lookup_by(self.short_qualified_name);
        }
+        let ty = self.variant.parent_enum(self.ctx.completion.db).ty(self.ctx.completion.db);
+        item.set_relevance(CompletionRelevance {
+            exact_type_match: compute_exact_type_match(self.ctx.completion, &ty),
+            ..CompletionRelevance::default()
+        });
+        if let Some(ref_match) = compute_ref_match(self.ctx.completion, &ty) {
+            item.ref_match(ref_match);
+        }
        item.build()
    }
diff --git a/crates/ide_completion/src/render/function.rs b/crates/ide_completion/src/render/function.rs
index 47e26a5d8..010303182 100644
--- a/crates/ide_completion/src/render/function.rs
+++ b/crates/ide_completion/src/render/function.rs
@@ -2,11 +2,15 @@
 use hir::{HasSource, HirDisplay, Type};
 use ide_db::SymbolKind;
+use itertools::Itertools;
 use syntax::ast::Fn;
 use crate::{
    item::{CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance, ImportEdit},
-    render::{builder_ext::Params, RenderContext},
+    render::{
+        builder_ext::Params, compute_exact_name_match, compute_exact_type_match, compute_ref_match,
+        RenderContext,
+    },
 };
 pub(crate) fn render_fn<'a>(
@@ -52,30 +56,60 @@ impl<'a> FunctionRender<'a> {
                self.ctx.is_deprecated(self.func) || self.ctx.is_deprecated_assoc_item(self.func),
            )
            .detail(self.detail())
-            .add_call_parens(self.ctx.completion, self.name, params)
+            .add_call_parens(self.ctx.completion, self.name.clone(), params)
            .add_import(import_to_add);
-        let mut relevance = CompletionRelevance::default();
+        let ret_type = self.func.ret_type(self.ctx.db());
-        if let Some(expected_type) = &self.ctx.completion.expected_type {
+        item.set_relevance(CompletionRelevance {
-            let ret_ty = self.func.ret_type(self.ctx.db());
+            exact_type_match: compute_exact_type_match(self.ctx.completion, &ret_type),
+            exact_name_match: compute_exact_name_match(self.ctx.completion, self.name.clone()),
+            ..CompletionRelevance::default()
+        });
-            // We don't ever consider a function which returns unit type to be an
+        if let Some(ref_match) = compute_ref_match(self.ctx.completion, &ret_type) {
-            // exact type match, since nearly always this is not meaningful to the
+            item.ref_match(ref_match);
-            // user.
-            relevance.exact_type_match = &ret_ty == expected_type && !ret_ty.is_unit();
        }
-        if let Some(expected_name) = &self.ctx.completion.expected_name {
-            relevance.exact_name_match =
-                expected_name == &self.func.name(self.ctx.db()).to_string();
-        }
-        item.set_relevance(relevance);
        item.build()
    }
    fn detail(&self) -> String {
-        let ty = self.func.ret_type(self.ctx.db());
+        let ret_ty = self.func.ret_type(self.ctx.db());
-        format!("-> {}", ty.display(self.ctx.db()))
+        let ret = if ret_ty.is_unit() {
+            // Omit the return type if it is the unit type
+            String::new()
+        } else {
+            format!(" {}", self.ty_display())
+        };
+        format!("fn({}){}", self.params_display(), ret)
+    }
+    fn params_display(&self) -> String {
+        if let Some(self_param) = self.func.self_param(self.ctx.db()) {
+            let params = self
+                .func
+                .assoc_fn_params(self.ctx.db())
+                .into_iter()
+                .skip(1) // skip the self param because we are manually handling that
+                .map(|p| p.ty().display(self.ctx.db()).to_string());
+            std::iter::once(self_param.display(self.ctx.db()).to_owned()).chain(params).join(", ")
+        } else {
+            let params = self
+                .func
+                .assoc_fn_params(self.ctx.db())
+                .into_iter()
+                .map(|p| p.ty().display(self.ctx.db()).to_string())
+                .join(", ");
+            params
+        }
+    }
+    fn ty_display(&self) -> String {
+        let ret_ty = self.func.ret_type(self.ctx.db());
+        format!("-> {}", ret_ty.display(self.ctx.db()))
    }
    fn add_arg(&self, arg: &str, ty: &Type) -> String {
diff --git a/crates/ide_db/src/call_info.rs b/crates/ide_db/src/call_info.rs
index d8878aa91..d4016973c 100644
--- a/crates/ide_db/src/call_info.rs
+++ b/crates/ide_db/src/call_info.rs
@@ -109,7 +109,7 @@ fn call_info_impl(
    token: SyntaxToken,
 ) -> Option<(hir::Callable, Option<usize>)> {
    // Find the calling expression and it's NameRef
-    let calling_node = FnCallNode::with_node(&token.parent())?;
+    let calling_node = FnCallNode::with_node(&token.parent()?)?;
    let callable = match &calling_node {
        FnCallNode::CallExpr(call) => sema.type_of_expr(&call.expr()?)?.as_callable(sema.db)?,
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index d00a8b6e7..f56221a6c 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -260,7 +260,7 @@ impl Definition {
            let mut res = source_root.iter().map(|id| (id, None)).collect::<FxHashMap<_, _>>();
            let krate = module.krate();
-            for rev_dep in krate.reverse_dependencies(db) {
+            for rev_dep in krate.transitive_reverse_dependencies(db) {
                let root_file = rev_dep.root_file(db);
                let source_root_id = db.file_source_root(root_file);
                let source_root = db.source_root(source_root_id);
diff --git a/crates/ide_ssr/src/resolving.rs b/crates/ide_ssr/src/resolving.rs
index af94c7bb1..dc7835473 100644
--- a/crates/ide_ssr/src/resolving.rs
+++ b/crates/ide_ssr/src/resolving.rs
@@ -195,7 +195,7 @@ impl<'db> ResolutionScope<'db> {
            .syntax()
            .token_at_offset(resolve_context.offset)
            .left_biased()
-            .map(|token| token.parent())
+            .and_then(|token| token.parent())
            .unwrap_or_else(|| file.syntax().clone());
        let node = pick_node_for_resolution(node);
        let scope = sema.scope(&node);
diff --git a/crates/mbe/src/tests.rs b/crates/mbe/src/tests.rs
index 3a168bb4b..eca0bcc18 100644
--- a/crates/mbe/src/tests.rs
+++ b/crates/mbe/src/tests.rs
@@ -662,12 +662,11 @@ fn test_tt_to_stmts() {
        [email protected]
          [email protected] "1"
    [email protected] ";"
-  [email protected]
+  [email protected]
-    [email protected]
+    [email protected]
-      [email protected]
+      [email protected]
-        [email protected]
+        [email protected]
-          [email protected]
+          [email protected] "a""#,
-            [email protected] "a""#,
    );
 }
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index 6c0e22722..cebb8f400 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -63,11 +63,11 @@ pub(crate) mod fragments {
    }
    pub(crate) fn stmt(p: &mut Parser) {
-        expressions::stmt(p, expressions::StmtWithSemi::No)
+        expressions::stmt(p, expressions::StmtWithSemi::No, true)
    }
    pub(crate) fn stmt_optional_semi(p: &mut Parser) {
-        expressions::stmt(p, expressions::StmtWithSemi::Optional)
+        expressions::stmt(p, expressions::StmtWithSemi::Optional, false)
    }
    pub(crate) fn opt_visibility(p: &mut Parser) {
@@ -133,7 +133,7 @@ pub(crate) mod fragments {
                continue;
            }
-            expressions::stmt(p, expressions::StmtWithSemi::Optional);
+            expressions::stmt(p, expressions::StmtWithSemi::Optional, true);
        }
        m.complete(p, MACRO_STMTS);
diff --git a/crates/parser/src/grammar/expressions.rs b/crates/parser/src/grammar/expressions.rs
index 5f885edfd..0d9dc9348 100644
--- a/crates/parser/src/grammar/expressions.rs
+++ b/crates/parser/src/grammar/expressions.rs
@@ -54,7 +54,7 @@ fn is_expr_stmt_attr_allowed(kind: SyntaxKind) -> bool {
    !forbid
 }
-pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
+pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi, prefer_expr: bool) {
    let m = p.start();
    // test attr_on_expr_stmt
    // fn foo() {
@@ -90,7 +90,7 @@ pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
        p.error(format!("attributes are not allowed on {:?}", kind));
    }
-    if p.at(T!['}']) {
+    if p.at(T!['}']) || (prefer_expr && p.at(EOF)) {
        // test attr_on_last_expr_in_block
        // fn foo() {
        //     { #[A] bar!()? }
@@ -198,7 +198,7 @@ pub(super) fn expr_block_contents(p: &mut Parser) {
            continue;
        }
-        stmt(p, StmtWithSemi::Yes)
+        stmt(p, StmtWithSemi::Yes, false)
    }
 }
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index c0fd894b0..74cafaa8d 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.12.2"
+rowan = "0.13.0-pre.2"
 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/algo.rs b/crates/syntax/src/algo.rs
index b13252eec..82ebf9037 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -4,7 +4,6 @@ use std::{
    fmt,
    hash::BuildHasherDefault,
    ops::{self, RangeInclusive},
-    ptr,
 };
 use indexmap::IndexMap;
@@ -27,7 +26,7 @@ pub fn ancestors_at_offset(
    offset: TextSize,
 ) -> impl Iterator<Item = SyntaxNode> {
    node.token_at_offset(offset)
-        .map(|token| token.parent().ancestors())
+        .map(|token| token.ancestors())
        .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
 }
@@ -171,7 +170,7 @@ pub fn diff(from: &SyntaxNode, to: &SyntaxNode) -> TreeDiff {
            && lhs.text_range().len() == rhs.text_range().len()
            && match (&lhs, &rhs) {
                (NodeOrToken::Node(lhs), NodeOrToken::Node(rhs)) => {
-                    ptr::eq(lhs.green(), rhs.green()) || lhs.text() == rhs.text()
+                    lhs == rhs || lhs.text() == rhs.text()
                }
                (NodeOrToken::Token(lhs), NodeOrToken::Token(rhs)) => lhs.text() == rhs.text(),
                _ => false,
@@ -280,9 +279,10 @@ fn _insert_children(
        to_green_element(element)
    });
-    let mut old_children = parent.green().children().map(|it| match it {
+    let parent_green = parent.green();
-        NodeOrToken::Token(it) => NodeOrToken::Token(it.clone()),
+    let mut old_children = parent_green.children().map(|it| match it {
-        NodeOrToken::Node(it) => NodeOrToken::Node(it.clone()),
+        NodeOrToken::Token(it) => NodeOrToken::Token(it.to_owned()),
+        NodeOrToken::Node(it) => NodeOrToken::Node(it.to_owned()),
    });
    let new_children = match &position {
@@ -319,9 +319,10 @@ fn _replace_children(
 ) -> SyntaxNode {
    let start = position_of_child(parent, to_delete.start().clone());
    let end = position_of_child(parent, to_delete.end().clone());
-    let mut old_children = parent.green().children().map(|it| match it {
+    let parent_green = parent.green();
-        NodeOrToken::Token(it) => NodeOrToken::Token(it.clone()),
+    let mut old_children = parent_green.children().map(|it| match it {
-        NodeOrToken::Node(it) => NodeOrToken::Node(it.clone()),
+        NodeOrToken::Token(it) => NodeOrToken::Token(it.to_owned()),
+        NodeOrToken::Node(it) => NodeOrToken::Node(it.to_owned()),
    });
    let before = old_children.by_ref().take(start).collect::<Vec<_>>();
@@ -487,9 +488,9 @@ impl<'a> SyntaxRewriter<'a> {
    /// Returns `None` when there are no replacements.
    pub fn rewrite_root(&self) -> Option<SyntaxNode> {
        let _p = profile::span("rewrite_root");
-        fn element_to_node_or_parent(element: &SyntaxElement) -> SyntaxNode {
+        fn element_to_node_or_parent(element: &SyntaxElement) -> Option<SyntaxNode> {
            match element {
-                SyntaxElement::Node(it) => it.clone(),
+                SyntaxElement::Node(it) => Some(it.clone()),
                SyntaxElement::Token(it) => it.parent(),
            }
        }
@@ -497,9 +498,9 @@ impl<'a> SyntaxRewriter<'a> {
        assert!(self.f.is_none());
        self.replacements
            .keys()
-            .map(element_to_node_or_parent)
+            .filter_map(element_to_node_or_parent)
-            .chain(self.insertions.keys().map(|pos| match pos {
+            .chain(self.insertions.keys().filter_map(|pos| match pos {
-                InsertPos::FirstChildOf(it) => it.clone(),
+                InsertPos::FirstChildOf(it) => Some(it.clone()),
                InsertPos::After(it) => element_to_node_or_parent(it),
            }))
            // If we only have one replacement/insertion, we must return its parent node, since `rewrite` does
@@ -552,7 +553,7 @@ impl<'a> SyntaxRewriter<'a> {
            };
        } else {
            match element {
-                NodeOrToken::Token(it) => acc.push(NodeOrToken::Token(it.green().clone())),
+                NodeOrToken::Token(it) => acc.push(NodeOrToken::Token(it.green().to_owned())),
                NodeOrToken::Node(it) => {
                    acc.push(NodeOrToken::Node(self.rewrite_children(it)));
                }
@@ -567,7 +568,7 @@ impl<'a> SyntaxRewriter<'a> {
 fn element_to_green(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
    match element {
        NodeOrToken::Node(it) => NodeOrToken::Node(it.green().to_owned()),
-        NodeOrToken::Token(it) => NodeOrToken::Token(it.green().clone()),
+        NodeOrToken::Token(it) => NodeOrToken::Token(it.green().to_owned()),
    }
 }
@@ -625,7 +626,7 @@ fn position_of_child(parent: &SyntaxNode, child: SyntaxElement) -> usize {
 fn to_green_element(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
    match element {
        NodeOrToken::Node(it) => it.green().to_owned().into(),
-        NodeOrToken::Token(it) => it.green().clone().into(),
+        NodeOrToken::Token(it) => it.green().to_owned().into(),
    }
 }
diff --git a/crates/syntax/src/ast.rs b/crates/syntax/src/ast.rs
index b3a24d39d..19261686c 100644
--- a/crates/syntax/src/ast.rs
+++ b/crates/syntax/src/ast.rs
@@ -6,6 +6,7 @@ mod token_ext;
 mod node_ext;
 mod expr_ext;
 pub mod edit;
+pub mod edit_in_place;
 pub mod make;
 use std::marker::PhantomData;
@@ -40,6 +41,12 @@ pub trait AstNode {
        Self: Sized;
    fn syntax(&self) -> &SyntaxNode;
+    fn clone_for_update(&self) -> Self
+    where
+        Self: Sized,
+    {
+        Self::cast(self.syntax().clone_for_update()).unwrap()
+    }
 }
 /// Like `AstNode`, but wraps tokens rather than interior nodes.
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
new file mode 100644
index 000000000..1788f2a40
--- /dev/null
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -0,0 +1,139 @@
+//! Structural editing for ast.
+use std::iter::empty;
+use ast::{edit::AstNodeEdit, make, GenericParamsOwner, WhereClause};
+use parser::T;
+use crate::{
+    ast,
+    ted::{self, Position},
+    AstNode, Direction, SyntaxKind,
+};
+use super::NameOwner;
+pub trait GenericParamsOwnerEdit: ast::GenericParamsOwner + AstNodeEdit {
+    fn get_or_create_where_clause(&self) -> ast::WhereClause;
+}
+impl GenericParamsOwnerEdit for ast::Fn {
+    fn get_or_create_where_clause(&self) -> WhereClause {
+        if self.where_clause().is_none() {
+            let position = if let Some(ty) = self.ret_type() {
+                Position::after(ty.syntax().clone())
+            } else if let Some(param_list) = self.param_list() {
+                Position::after(param_list.syntax().clone())
+            } else {
+                Position::last_child_of(self.syntax().clone())
+            };
+            create_where_clause(position, true)
+        }
+        self.where_clause().unwrap()
+    }
+}
+impl GenericParamsOwnerEdit for ast::Impl {
+    fn get_or_create_where_clause(&self) -> WhereClause {
+        if self.where_clause().is_none() {
+            let position = if let Some(items) = self.assoc_item_list() {
+                Position::before(items.syntax().clone())
+            } else {
+                Position::last_child_of(self.syntax().clone())
+            };
+            create_where_clause(position, false)
+        }
+        self.where_clause().unwrap()
+    }
+}
+impl GenericParamsOwnerEdit for ast::Trait {
+    fn get_or_create_where_clause(&self) -> WhereClause {
+        if self.where_clause().is_none() {
+            let position = if let Some(items) = self.assoc_item_list() {
+                Position::before(items.syntax().clone())
+            } else {
+                Position::last_child_of(self.syntax().clone())
+            };
+            create_where_clause(position, false)
+        }
+        self.where_clause().unwrap()
+    }
+}
+impl GenericParamsOwnerEdit for ast::Struct {
+    fn get_or_create_where_clause(&self) -> WhereClause {
+        if self.where_clause().is_none() {
+            let tfl = self.field_list().and_then(|fl| match fl {
+                ast::FieldList::RecordFieldList(_) => None,
+                ast::FieldList::TupleFieldList(it) => Some(it),
+            });
+            let position = if let Some(tfl) = tfl {
+                Position::after(tfl.syntax().clone())
+            } else if let Some(gpl) = self.generic_param_list() {
+                Position::after(gpl.syntax().clone())
+            } else if let Some(name) = self.name() {
+                Position::after(name.syntax().clone())
+            } else {
+                Position::last_child_of(self.syntax().clone())
+            };
+            create_where_clause(position, true)
+        }
+        self.where_clause().unwrap()
+    }
+}
+impl GenericParamsOwnerEdit for ast::Enum {
+    fn get_or_create_where_clause(&self) -> WhereClause {
+        if self.where_clause().is_none() {
+            let position = if let Some(gpl) = self.generic_param_list() {
+                Position::after(gpl.syntax().clone())
+            } else if let Some(name) = self.name() {
+                Position::after(name.syntax().clone())
+            } else {
+                Position::last_child_of(self.syntax().clone())
+            };
+            create_where_clause(position, true)
+        }
+        self.where_clause().unwrap()
+    }
+}
+fn create_where_clause(position: Position, after: bool) {
+    let mut elements = vec![make::where_clause(empty()).clone_for_update().syntax().clone().into()];
+    let ws = make::tokens::single_space().into();
+    if after {
+        elements.insert(0, ws)
+    } else {
+        elements.push(ws)
+    }
+    ted::insert_all(position, elements);
+}
+impl ast::WhereClause {
+    pub fn add_predicate(&self, predicate: ast::WherePred) {
+        if let Some(pred) = self.predicates().last() {
+            if !pred.syntax().siblings_with_tokens(Direction::Next).any(|it| it.kind() == T![,]) {
+                ted::append_child(self.syntax().clone(), make::token(T![,]));
+            }
+        }
+        if self.syntax().children_with_tokens().last().map(|it| it.kind())
+            != Some(SyntaxKind::WHITESPACE)
+        {
+            ted::append_child(self.syntax().clone(), make::tokens::single_space());
+        }
+        ted::append_child(self.syntax().clone(), predicate.syntax().clone())
+    }
+}
+impl ast::TypeBoundList {
+    pub fn remove(&self) {
+        if let Some(colon) =
+            self.syntax().siblings_with_tokens(Direction::Prev).find(|it| it.kind() == T![:])
+        {
+            ted::remove_all(colon..=self.syntax().clone().into())
+        } else {
+            ted::remove(self.syntax().clone())
+        }
+    }
+}
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index 064931aec..6097178b6 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/crates/syntax/src/ast/generated/nodes.rs
@@ -1336,6 +1336,7 @@ pub enum Expr {
    Literal(Literal),
    LoopExpr(LoopExpr),
    MacroCall(MacroCall),
+    MacroStmts(MacroStmts),
    MatchExpr(MatchExpr),
    MethodCallExpr(MethodCallExpr),
    ParenExpr(ParenExpr),
@@ -3034,6 +3035,9 @@ impl From<LoopExpr> for Expr {
 impl From<MacroCall> for Expr {
    fn from(node: MacroCall) -> Expr { Expr::MacroCall(node) }
 }
+impl From<MacroStmts> for Expr {
+    fn from(node: MacroStmts) -> Expr { Expr::MacroStmts(node) }
+}
 impl From<MatchExpr> for Expr {
    fn from(node: MatchExpr) -> Expr { Expr::MatchExpr(node) }
 }
@@ -3078,8 +3082,8 @@ impl AstNode for Expr {
        match kind {
            ARRAY_EXPR | AWAIT_EXPR | BIN_EXPR | BLOCK_EXPR | BOX_EXPR | BREAK_EXPR | CALL_EXPR
            | CAST_EXPR | CLOSURE_EXPR | CONTINUE_EXPR | EFFECT_EXPR | FIELD_EXPR | FOR_EXPR
-            | IF_EXPR | INDEX_EXPR | LITERAL | LOOP_EXPR | MACRO_CALL | MATCH_EXPR
+            | IF_EXPR | INDEX_EXPR | LITERAL | LOOP_EXPR | MACRO_CALL | MACRO_STMTS
-            | METHOD_CALL_EXPR | PAREN_EXPR | PATH_EXPR | PREFIX_EXPR | RANGE_EXPR
+            | MATCH_EXPR | METHOD_CALL_EXPR | PAREN_EXPR | PATH_EXPR | PREFIX_EXPR | RANGE_EXPR
            | RECORD_EXPR | REF_EXPR | RETURN_EXPR | TRY_EXPR | TUPLE_EXPR | WHILE_EXPR
            | YIELD_EXPR => true,
            _ => false,
@@ -3105,6 +3109,7 @@ impl AstNode for Expr {
            LITERAL => Expr::Literal(Literal { syntax }),
            LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
            MACRO_CALL => Expr::MacroCall(MacroCall { syntax }),
+            MACRO_STMTS => Expr::MacroStmts(MacroStmts { syntax }),
            MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
            METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
            PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
@@ -3142,6 +3147,7 @@ impl AstNode for Expr {
            Expr::Literal(it) => &it.syntax,
            Expr::LoopExpr(it) => &it.syntax,
            Expr::MacroCall(it) => &it.syntax,
+            Expr::MacroStmts(it) => &it.syntax,
            Expr::MatchExpr(it) => &it.syntax,
            Expr::MethodCallExpr(it) => &it.syntax,
            Expr::ParenExpr(it) => &it.syntax,
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 05a6b0b25..810c8d4c8 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -174,6 +174,11 @@ pub fn block_expr(
 pub fn expr_unit() -> ast::Expr {
    expr_from_text("()")
 }
+pub fn expr_literal(text: &str) -> ast::Literal {
+    assert_eq!(text.trim(), text);
+    ast_from_text(&format!("fn f() {{ let _ = {}; }}", text))
+}
 pub fn expr_empty_block() -> ast::Expr {
    expr_from_text("{}")
 }
@@ -390,6 +395,7 @@ pub fn token(kind: SyntaxKind) -> SyntaxToken {
    tokens::SOURCE_FILE
        .tree()
        .syntax()
+        .clone_for_update()
        .descendants_with_tokens()
        .filter_map(|it| it.into_token())
        .find(|it| it.kind() == kind)
@@ -544,6 +550,7 @@ pub mod tokens {
        SOURCE_FILE
            .tree()
            .syntax()
+            .clone_for_update()
            .descendants_with_tokens()
            .filter_map(|it| it.into_token())
            .find(|it| it.kind() == WHITESPACE && it.text() == " ")
@@ -569,13 +576,16 @@ pub mod tokens {
    }
    pub fn single_newline() -> SyntaxToken {
-        SOURCE_FILE
+        let res = SOURCE_FILE
            .tree()
            .syntax()
+            .clone_for_update()
            .descendants_with_tokens()
            .filter_map(|it| it.into_token())
            .find(|it| it.kind() == WHITESPACE && it.text() == "\n")
-            .unwrap()
+            .unwrap();
+        res.detach();
+        res
    }
    pub fn blank_line() -> SyntaxToken {
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index 52ac97c84..0b0d39a75 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -34,7 +34,9 @@ impl ast::NameRef {
 }
 fn text_of_first_token(node: &SyntaxNode) -> &str {
-    node.green().children().next().and_then(|it| it.into_token()).unwrap().text()
+    let t =
+        node.green().children().next().and_then(|it| it.into_token()).unwrap().text().to_string();
+    Box::leak(Box::new(t))
 }
 pub enum Macro {
diff --git a/crates/syntax/src/lib.rs b/crates/syntax/src/lib.rs
index 09e212e8c..2a5c61171 100644
--- a/crates/syntax/src/lib.rs
+++ b/crates/syntax/src/lib.rs
@@ -38,6 +38,7 @@ pub mod ast;
 #[doc(hidden)]
 pub mod fuzz;
 pub mod utils;
+pub mod ted;
 use std::{marker::PhantomData, sync::Arc};
diff --git a/crates/syntax/src/parsing/reparsing.rs b/crates/syntax/src/parsing/reparsing.rs
index 3d637bf91..4ad50ab72 100644
--- a/crates/syntax/src/parsing/reparsing.rs
+++ b/crates/syntax/src/parsing/reparsing.rs
@@ -124,11 +124,7 @@ fn is_contextual_kw(text: &str) -> bool {
 fn find_reparsable_node(node: &SyntaxNode, range: TextRange) -> Option<(SyntaxNode, Reparser)> {
    let node = node.covering_element(range);
-    let mut ancestors = match node {
+    node.ancestors().find_map(|node| {
-        NodeOrToken::Token(it) => it.parent().ancestors(),
-        NodeOrToken::Node(it) => it.ancestors(),
-    };
-    ancestors.find_map(|node| {
        let first_child = node.first_child_or_token().map(|it| it.kind());
        let parent = node.parent().map(|it| it.kind());
        Reparser::for_node(node.kind(), first_child, parent).map(|r| (node, r))
diff --git a/crates/syntax/src/ted.rs b/crates/syntax/src/ted.rs
new file mode 100644
index 000000000..8d6175ed9
--- /dev/null
+++ b/crates/syntax/src/ted.rs
@@ -0,0 +1,78 @@
+//! Primitive tree editor, ed for trees
+#![allow(unused)]
+use std::ops::RangeInclusive;
+use crate::{SyntaxElement, SyntaxNode};
+#[derive(Debug)]
+pub struct Position {
+    repr: PositionRepr,
+}
+#[derive(Debug)]
+enum PositionRepr {
+    FirstChild(SyntaxNode),
+    After(SyntaxElement),
+}
+impl Position {
+    pub fn after(elem: impl Into<SyntaxElement>) -> Position {
+        let repr = PositionRepr::After(elem.into());
+        Position { repr }
+    }
+    pub fn before(elem: impl Into<SyntaxElement>) -> Position {
+        let elem = elem.into();
+        let repr = match elem.prev_sibling_or_token() {
+            Some(it) => PositionRepr::After(it),
+            None => PositionRepr::FirstChild(elem.parent().unwrap()),
+        };
+        Position { repr }
+    }
+    pub fn first_child_of(node: impl Into<SyntaxNode>) -> Position {
+        let repr = PositionRepr::FirstChild(node.into());
+        Position { repr }
+    }
+    pub fn last_child_of(node: impl Into<SyntaxNode>) -> Position {
+        let node = node.into();
+        let repr = match node.last_child_or_token() {
+            Some(it) => PositionRepr::After(it),
+            None => PositionRepr::FirstChild(node),
+        };
+        Position { repr }
+    }
+}
+pub fn insert(position: Position, elem: impl Into<SyntaxElement>) {
+    insert_all(position, vec![elem.into()])
+}
+pub fn insert_all(position: Position, elements: Vec<SyntaxElement>) {
+    let (parent, index) = match position.repr {
+        PositionRepr::FirstChild(parent) => (parent, 0),
+        PositionRepr::After(child) => (child.parent().unwrap(), child.index() + 1),
+    };
+    parent.splice_children(index..index, elements);
+}
+pub fn remove(elem: impl Into<SyntaxElement>) {
+    let elem = elem.into();
+    remove_all(elem.clone()..=elem)
+}
+pub fn remove_all(range: RangeInclusive<SyntaxElement>) {
+    replace_all(range, Vec::new())
+}
+pub fn replace(old: impl Into<SyntaxElement>, new: impl Into<SyntaxElement>) {
+    let old = old.into();
+    replace_all(old.clone()..=old, vec![new.into()])
+}
+pub fn replace_all(range: RangeInclusive<SyntaxElement>, new: Vec<SyntaxElement>) {
+    let start = range.start().index();
+    let end = range.end().index();
+    let parent = range.start().parent().unwrap();
+    parent.splice_children(start..end + 1, new)
+}
+pub fn append_child(node: impl Into<SyntaxNode>, child: impl Into<SyntaxElement>) {
+    let position = Position::last_child_of(node);
+    insert(position, child)
+}
diff --git a/crates/test_utils/src/fixture.rs b/crates/test_utils/src/fixture.rs
index e3f57f3b2..6bc824e94 100644
--- a/crates/test_utils/src/fixture.rs
+++ b/crates/test_utils/src/fixture.rs
@@ -14,6 +14,7 @@ pub struct Fixture {
    pub cfg_key_values: Vec<(String, String)>,
    pub edition: Option<String>,
    pub env: FxHashMap<String, String>,
+    pub introduce_new_source_root: bool,
 }
 impl Fixture {
@@ -70,6 +71,7 @@ impl Fixture {
        let mut cfg_atoms = Vec::new();
        let mut cfg_key_values = Vec::new();
        let mut env = FxHashMap::default();
+        let mut introduce_new_source_root = false;
        for component in components[1..].iter() {
            let (key, value) = split_once(component, ':').unwrap();
            match key {
@@ -91,11 +93,22 @@ impl Fixture {
                        }
                    }
                }
+                "new_source_root" => introduce_new_source_root = true,
                _ => panic!("bad component: {:?}", component),
            }
        }
-        Fixture { path, text: String::new(), krate, deps, cfg_atoms, cfg_key_values, edition, env }
+        Fixture {
+            path,
+            text: String::new(),
+            krate,
+            deps,
+            cfg_atoms,
+            cfg_key_values,
+            edition,
+            env,
+            introduce_new_source_root,
+        }
    }
 }