65 files changed, 1674 insertions, 446 deletions
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 32c7cf7ef..ae9dccce9 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -13,6 +13,7 @@ env:
  CARGO_NET_RETRY: 10
  RUSTFLAGS: "-D warnings -W unreachable-pub"
  RUSTUP_MAX_RETRIES: 10
+  FETCH_DEPTH: 200
 jobs:
  dist-x86_64-pc-windows-msvc:
@@ -24,6 +25,8 @@ jobs:
    steps:
    - name: Checkout repository
      uses: actions/checkout@v2
+      with:
+        fetch-depth: ${{ env.FETCH_DEPTH }}
    # We need to disable the existing toolchain to avoid updating rust-docs
    # which takes a long time. The fastest way to do this is to rename the
@@ -57,6 +60,8 @@ jobs:
    steps:
    - name: Checkout repository
      uses: actions/checkout@v2
+      with:
+        fetch-depth: ${{ env.FETCH_DEPTH }}
    - name: Rename existing rust toolchain
      run: Rename-Item C:\Users\runneradmin\.rustup\toolchains\stable-x86_64-pc-windows-msvc C:\Users\runneradmin\.rustup\toolchains\stable-x86_64-pc-windows-msvc.old
@@ -87,6 +92,8 @@ jobs:
    steps:
    - name: Checkout repository
      uses: actions/checkout@v2
+      with:
+        fetch-depth: ${{ env.FETCH_DEPTH }}
    - name: Install Rust toolchain
      uses: actions-rs/toolchain@v1
@@ -139,6 +146,8 @@ jobs:
    - name: Checkout repository
      uses: actions/checkout@v2
+      with:
+        fetch-depth: ${{ env.FETCH_DEPTH }}
    - name: Dist
      run: cargo xtask dist
@@ -159,6 +168,8 @@ jobs:
    steps:
    - name: Checkout repository
      uses: actions/checkout@v2
+      with:
+        fetch-depth: ${{ env.FETCH_DEPTH }}
    - name: Install Rust toolchain
      uses: actions-rs/toolchain@v1
@@ -193,6 +204,8 @@ jobs:
    - name: Checkout repository
      uses: actions/checkout@v2
+      with:
+        fetch-depth: ${{ env.FETCH_DEPTH }}
    - name: Install Rust toolchain
      uses: actions-rs/toolchain@v1
@@ -223,6 +236,8 @@ jobs:
    - name: Checkout repository
      uses: actions/checkout@v2
+      with:
+        fetch-depth: ${{ env.FETCH_DEPTH }}
    - name: Install Rust toolchain
      uses: actions-rs/toolchain@v1
@@ -259,6 +274,8 @@ jobs:
    - name: Checkout repository
      uses: actions/checkout@v2
+      with:
+        fetch-depth: ${{ env.FETCH_DEPTH }}
    - run: echo "HEAD_SHA=$(git rev-parse HEAD)" >> $GITHUB_ENV
    - run: 'echo "HEAD_SHA: $HEAD_SHA"'
diff --git a/Cargo.lock b/Cargo.lock
index 2efae6a01..b99c243a4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,7 +1,5 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
 [[package]]
 name = "addr2line"
 version = "0.14.1"
@@ -1326,9 +1324,9 @@ checksum = "b5eb417147ba9860a96cfe72a0b93bf88fee1744b5636ec99ab20c1aa9376581"
 [[package]]
 name = "rowan"
-version = "0.12.6"
+version = "0.13.0-pre.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1b36e449f3702f3b0c821411db1cbdf30fb451726a9456dce5dabcd44420043"
+checksum = "8f300be7fa17c3fa563d2bc6ab5b1a8d5163162f9111599eda4f86a563714724"
 dependencies = [
 "countme",
 "hashbrown",
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs
new file mode 100644
index 000000000..44cdcc296
--- /dev/null
+++ b/crates/hir/src/display.rs
@@ -0,0 +1,441 @@
+//! 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::{
+    Const, ConstParam, Enum, Field, Function, HasVisibility, Module, Static, Struct, Substs, 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 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 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(())
+    }
+}
+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..f0bc2c7b9 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,8 +52,8 @@ 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,
@@ -571,6 +573,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 +611,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 +644,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 +841,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 +850,7 @@ impl Function {
                        environment: environment.clone(),
                    },
                };
-                Param { ty }
+                Param { func: self, ty, idx }
            })
            .collect()
    }
@@ -843,7 +864,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 +913,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 +923,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 +954,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 +989,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 +1026,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 +1051,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()))
    }
 }
@@ -1412,19 +1469,6 @@ impl TypeParam {
    }
 }
-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,
@@ -1631,6 +1675,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())),
@@ -2054,12 +2102,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_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/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 86239d903..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},
@@ -556,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,
@@ -629,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/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/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..c572bb114 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;
@@ -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)
    }
@@ -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/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 232cf9cd0..4bd8ba303 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -429,7 +429,7 @@ pub(crate) fn trait_datum_query(
    let generic_params = generics(db.upcast(), trait_.into());
    let bound_vars = Substs::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
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..1f7b665c0 100644
--- a/crates/ide/src/display.rs
+++ b/crates/ide/src/display.rs
@@ -5,6 +5,5 @@ 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};
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 198243466..69c3751a1 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -3,7 +3,9 @@
 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,
+};
 use ide_db::{
    base_db::{FileId, FileRange, SourceDatabase},
    symbol_index::FileSymbolKind,
@@ -98,7 +100,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 +253,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 +264,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 +319,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) => {
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..8d45b4875 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,
+    Adt, 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,34 +335,18 @@ 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(Adt::Struct(it)) => from_hir_fmt(db, it, mod_path),
-                match it.definition_source(db).value {
+            ModuleDef::Adt(Adt::Union(it)) => from_hir_fmt(db, it, mod_path),
-                    ModuleSource::Module(it) => it.short_label(),
+            ModuleDef::Adt(Adt::Enum(it)) => from_hir_fmt(db, it, mod_path),
-                    ModuleSource::SourceFile(it) => it.short_label(),
+            ModuleDef::Variant(it) => from_hir_fmt(db, it, mod_path),
-                    ModuleSource::BlockExpr(it) => it.short_label(),
+            ModuleDef::Const(it) => from_hir_fmt(db, it, mod_path),
-                },
+            ModuleDef::Static(it) => from_hir_fmt(db, it, mod_path),
-                mod_path,
+            ModuleDef::Trait(it) => from_hir_fmt(db, it, mod_path),
-            ),
+            ModuleDef::TypeAlias(it) => from_hir_fmt(db, it, 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()))),
@@ -370,26 +354,25 @@ fn hover_for_definition(
        Definition::Local(it) => hover_for_local(it, db),
        Definition::SelfType(impl_def) => {
            impl_def.target_ty(db).as_adt().and_then(|adt| match adt {
-                Adt::Struct(it) => from_def_source(db, it, mod_path),
+                Adt::Struct(it) => from_hir_fmt(db, it, mod_path),
-                Adt::Union(it) => from_def_source(db, it, mod_path),
+                Adt::Union(it) => from_hir_fmt(db, it, mod_path),
-                Adt::Enum(it) => from_def_source(db, it, mod_path),
+                Adt::Enum(it) => from_hir_fmt(db, it, mod_path),
            })
        }
        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),
+            GenericParam::ConstParam(it) => Some(Markup::fenced_block(&it.display(db))),
        },
    };
-    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 +421,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 +653,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 +863,7 @@ fn main() { So$0me(12); }
                ```
                ```rust
-                Some
+                Some(T)
                ```
            "#]],
        );
@@ -944,7 +929,7 @@ fn main() {
                ```
                ```rust
-                Some
+                Some(T)
                ```
                ---
@@ -1441,13 +1426,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 +1475,18 @@ extern crate st$0d;
 //! abc123
            "#,
            expect![[r#"
-            *std*
+                *std*
-            Standard library for this test
+                ```rust
+                extern crate std
+                ```
-            Printed?
+                ---
-            abc123
+                Standard library for this test
+                Printed?
+                abc123
            "#]],
        );
        check(
@@ -1507,11 +1500,18 @@ extern crate std as ab$0c;
 //! abc123
            "#,
            expect![[r#"
-            *abc*
+                *abc*
-            Standard library for this test
+                ```rust
+                extern crate std
+                ```
+                ---
-            Printed?
+                Standard library for this test
-            abc123
+                Printed?
+                abc123
            "#]],
        );
    }
@@ -2021,7 +2021,7 @@ enum E {
                ```
                ```rust
-                V
+                V { field: i32 }
                ```
                ---
@@ -2417,7 +2417,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 +2463,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 +2605,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 +2702,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 +2715,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 +2819,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 +2916,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 +2966,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 +3042,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 +3090,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 +3103,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 +3116,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 +3582,17 @@ mod foo$0;
 "#,
            expect![[r#"
                *foo*
+                ```rust
+                test
+                ```
+                ```rust
+                mod foo
+                ```
+                ---
                For the horde!
            "#]],
        );
@@ -3606,7 +3617,7 @@ use foo::bar::{self$0};
                ```
                ```rust
-                pub mod bar
+                mod bar
                ```
                ---
@@ -3657,4 +3668,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..e8a5666bc 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(),
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..48efa67ed 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())
        },
    )
 }
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 5a081de7e..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 {
@@ -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..36655667c 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,44 @@ 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();
+    if let Some(expected_type) = ctx.expected_type.as_ref() {
+        // 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()
+    } else {
+        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 mut ref_match = None;
+    if let Some(expected_type) = &ctx.expected_type {
+        if completion_ty != expected_type {
+            if let Some(expected_type_without_ref) = expected_type.remove_ref() {
+                if completion_ty == &expected_type_without_ref
+                    || 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
+                    };
+                    ref_match = Some(mutability);
+                }
+            }
+        }
+    };
+    ref_match
 }
 #[cfg(test)]
@@ -432,6 +452,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 +535,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 +561,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 +576,7 @@ fn main() { let _: m::Spam = S$0 }
                            Function,
                        ),
                        lookup: "main",
-                        detail: "-> ()",
+                        detail: "fn()",
                    },
                ]
            "#]],
@@ -537,7 +605,7 @@ fn main() { som$0 }
                            Function,
                        ),
                        lookup: "main",
-                        detail: "-> ()",
+                        detail: "fn()",
                    },
                    CompletionItem {
                        label: "something_deprecated()",
@@ -548,7 +616,7 @@ fn main() { som$0 }
                            Function,
                        ),
                        lookup: "something_deprecated",
-                        detail: "-> ()",
+                        detail: "fn()",
                        deprecated: true,
                    },
                    CompletionItem {
@@ -560,7 +628,7 @@ fn main() { som$0 }
                            Function,
                        ),
                        lookup: "something_else_deprecated",
-                        detail: "-> ()",
+                        detail: "fn()",
                        deprecated: true,
                    },
                ]
@@ -611,7 +679,7 @@ impl S {
                        insert: "bar()$0",
                        kind: Method,
                        lookup: "bar",
-                        detail: "-> ()",
+                        detail: "fn(self)",
                        documentation: Documentation(
                            "Method docs",
                        ),
@@ -711,7 +779,7 @@ fn foo(s: S) { s.$0 }
                        insert: "the_method()$0",
                        kind: Method,
                        lookup: "the_method",
-                        detail: "-> ()",
+                        detail: "fn(&self)",
                    },
                ]
            "#]],
@@ -1019,7 +1087,7 @@ fn main() {
                            Function,
                        ),
                        lookup: "foo",
-                        detail: "-> ()",
+                        detail: "fn(&mut S)",
                        trigger_call_info: true,
                    },
                    CompletionItem {
@@ -1031,7 +1099,7 @@ fn main() {
                            Function,
                        ),
                        lookup: "main",
-                        detail: "-> ()",
+                        detail: "fn()",
                    },
                    CompletionItem {
                        label: "s",
@@ -1169,4 +1237,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_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/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..06cde591d
--- /dev/null
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -0,0 +1,105 @@
+//! 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)
+        }
+        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(ty) = self.self_ty() {
+                Position::after(ty.syntax().clone())
+            } else {
+                Position::last_child_of(self.syntax().clone())
+            };
+            create_where_clause(position)
+        }
+        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)
+        }
+        self.where_clause().unwrap()
+    }
+}
+fn create_where_clause(position: Position) {
+    let elements = vec![
+        make::tokens::single_space().into(),
+        make::where_clause(empty()).clone_for_update().syntax().clone().into(),
+    ];
+    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/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/docs/dev/style.md b/docs/dev/style.md
index c4eb7bc7a..e4a1672ca 100644
--- a/docs/dev/style.md
+++ b/docs/dev/style.md
@@ -787,6 +787,27 @@ assert!(0 > x);
 **Rationale:** Less-then comparisons are more intuitive, they correspond spatially to [real line](https://en.wikipedia.org/wiki/Real_line).
+## If-let
+Avoid `if let ... { } else { }` construct, use `match` instead.
+```rust
+// GOOD
+match ctx.expected_type.as_ref() {
+    Some(expected_type) => completion_ty == expected_type && !expected_type.is_unit(),
+    None => false,
+}
+// BAD
+if let Some(expected_type) = ctx.expected_type.as_ref() {
+    completion_ty == expected_type && !expected_type.is_unit()
+} else {
+    false
+}
+```
+**Rational:** `match` is almost always more compact.
+The `else` branch can get a more precise pattern: `None` or `Err(_)` instead of `_`.
 ## Token names