43 files changed, 409 insertions, 260 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 0ca0b7b63..c378014f0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1319,9 +1319,9 @@ checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
 [[package]]
 name = "rowan"
-version = "0.13.0-pre.3"
+version = "0.13.0-pre.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77d315d6f2e33f294412faa47f41b56bdb3fce72c999d384b5e78c8d21551b13"
+checksum = "32a5fc82ed0b7e7fba157331f0d8f64abd73bced6e7ac2a4dfa0c4cf0ab584e8"
 dependencies = [
 "countme",
 "hashbrown",
@@ -1411,9 +1411,9 @@ checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
 [[package]]
 name = "salsa"
-version = "0.16.0"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8fadca2ab5de17acf66d744f4888049ca8f1bb9b8a1ab8afd9d032cc959c5dc"
+checksum = "4b84d9f96071f3f3be0dc818eae3327625d8ebc95b58da37d6850724f31d3403"
 dependencies = [
 "crossbeam-utils",
 "indexmap",
diff --git a/Cargo.toml b/Cargo.toml
index 46c64d35c..d34251fc0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,3 +27,5 @@ debug = 0 # Set this to 1 or 2 to get more useful backtraces in debugger.
 # chalk-recursive = { path = "../chalk/chalk-recursive" }
 # ungrammar = { path = "../ungrammar" }
+# salsa = { path = "../salsa" }
diff --git a/crates/hir/src/attrs.rs b/crates/hir/src/attrs.rs
index 4a11622fc..e8fa3c56e 100644
--- a/crates/hir/src/attrs.rs
+++ b/crates/hir/src/attrs.rs
@@ -112,7 +112,7 @@ fn resolve_doc_path(
        AttrDefId::MacroDefId(_) => return None,
    };
    let path = ast::Path::parse(link).ok()?;
-    let modpath = ModPath::from_src(path, &Hygiene::new_unhygienic()).unwrap();
+    let modpath = ModPath::from_src(db.upcast(), path, &Hygiene::new_unhygienic()).unwrap();
    let resolved = resolver.resolve_module_path_in_items(db.upcast(), &modpath);
    if resolved == PerNs::none() {
        if let Some(trait_id) = resolver.resolve_module_path_in_trait_items(db.upcast(), &modpath) {
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index d8ccfde0c..f876339de 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -1666,7 +1666,7 @@ impl Impl {
            .value
            .attrs()
            .filter_map(|it| {
-                let path = ModPath::from_src(it.path()?, &hygenic)?;
+                let path = ModPath::from_src(db.upcast(), it.path()?, &hygenic)?;
                if path.as_ident()?.to_string() == "derive" {
                    Some(it)
                } else {
@@ -1744,6 +1744,10 @@ impl Type {
        }
    }
+    pub fn strip_references(&self) -> Type {
+        self.derived(self.ty.strip_references().clone())
+    }
    pub fn is_unknown(&self) -> bool {
        self.ty.is_unknown()
    }
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 0895bd6f1..b5c65808e 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -283,7 +283,7 @@ impl SourceAnalyzer {
        // This must be a normal source file rather than macro file.
        let hygiene = Hygiene::new(db.upcast(), self.file_id);
-        let ctx = body::LowerCtx::with_hygiene(&hygiene);
+        let ctx = body::LowerCtx::with_hygiene(db.upcast(), &hygiene);
        let hir_path = Path::from_src(path.clone(), &ctx)?;
        // Case where path is a qualifier of another path, e.g. foo::bar::Baz where we
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 0171d8a92..a2479016e 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -95,13 +95,17 @@ impl ops::Deref for AttrsWithOwner {
 impl RawAttrs {
    pub(crate) const EMPTY: Self = Self { entries: None };
-    pub(crate) fn new(owner: &dyn ast::AttrsOwner, hygiene: &Hygiene) -> Self {
+    pub(crate) fn new(
+        db: &dyn DefDatabase,
+        owner: &dyn ast::AttrsOwner,
+        hygiene: &Hygiene,
+    ) -> Self {
        let entries = collect_attrs(owner)
            .enumerate()
            .flat_map(|(i, attr)| {
                let index = AttrId(i as u32);
                match attr {
-                    Either::Left(attr) => Attr::from_src(attr, hygiene, index),
+                    Either::Left(attr) => Attr::from_src(db, attr, hygiene, index),
                    Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
                        id: index,
                        input: Some(AttrInput::Literal(SmolStr::new(doc))),
@@ -116,7 +120,7 @@ impl RawAttrs {
    fn from_attrs_owner(db: &dyn DefDatabase, owner: InFile<&dyn ast::AttrsOwner>) -> Self {
        let hygiene = Hygiene::new(db.upcast(), owner.file_id);
-        Self::new(owner.value, &hygiene)
+        Self::new(db, owner.value, &hygiene)
    }
    pub(crate) fn merge(&self, other: Self) -> Self {
@@ -170,7 +174,7 @@ impl RawAttrs {
                    let attr = ast::Attr::parse(&format!("#[{}]", tree)).ok()?;
                    // FIXME hygiene
                    let hygiene = Hygiene::new_unhygienic();
-                    Attr::from_src(attr, &hygiene, index)
+                    Attr::from_src(db, attr, &hygiene, index)
                });
                let cfg_options = &crate_graph[krate].cfg_options;
@@ -627,8 +631,13 @@ pub enum AttrInput {
 }
 impl Attr {
-    fn from_src(ast: ast::Attr, hygiene: &Hygiene, id: AttrId) -> Option<Attr> {
+    fn from_src(
-        let path = Interned::new(ModPath::from_src(ast.path()?, hygiene)?);
+        db: &dyn DefDatabase,
+        ast: ast::Attr,
+        hygiene: &Hygiene,
+        id: AttrId,
+    ) -> Option<Attr> {
+        let path = Interned::new(ModPath::from_src(db, ast.path()?, hygiene)?);
        let input = if let Some(ast::Expr::Literal(lit)) = ast.expr() {
            let value = match lit.kind() {
                ast::LiteralKind::String(string) => string.value()?.into(),
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 131f424cc..8360426f1 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -72,7 +72,7 @@ impl CfgExpander {
    }
    pub(crate) fn parse_attrs(&self, db: &dyn DefDatabase, owner: &dyn ast::AttrsOwner) -> Attrs {
-        RawAttrs::new(owner, &self.hygiene).filter(db, self.krate)
+        RawAttrs::new(db, owner, &self.hygiene).filter(db, self.krate)
    }
    pub(crate) fn is_cfg_enabled(&self, db: &dyn DefDatabase, owner: &dyn ast::AttrsOwner) -> bool {
@@ -192,8 +192,8 @@ impl Expander {
        self.current_file_id
    }
-    fn parse_path(&mut self, path: ast::Path) -> Option<Path> {
+    fn parse_path(&mut self, db: &dyn DefDatabase, path: ast::Path) -> Option<Path> {
-        let ctx = LowerCtx::with_hygiene(&self.cfg_expander.hygiene);
+        let ctx = LowerCtx::with_hygiene(db, &self.cfg_expander.hygiene);
        Path::from_src(path, &ctx)
    }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index c11da30d2..75dc19c11 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -40,23 +40,25 @@ use crate::{
 use super::{diagnostics::BodyDiagnostic, ExprSource, PatSource};
-pub struct LowerCtx {
+pub struct LowerCtx<'a> {
+    pub db: &'a dyn DefDatabase,
    hygiene: Hygiene,
    file_id: Option<HirFileId>,
    source_ast_id_map: Option<Arc<AstIdMap>>,
 }
-impl LowerCtx {
+impl<'a> LowerCtx<'a> {
-    pub fn new(db: &dyn DefDatabase, file_id: HirFileId) -> Self {
+    pub fn new(db: &'a dyn DefDatabase, file_id: HirFileId) -> Self {
        LowerCtx {
+            db,
            hygiene: Hygiene::new(db.upcast(), file_id),
            file_id: Some(file_id),
            source_ast_id_map: Some(db.ast_id_map(file_id)),
        }
    }
-    pub fn with_hygiene(hygiene: &Hygiene) -> Self {
+    pub fn with_hygiene(db: &'a dyn DefDatabase, hygiene: &Hygiene) -> Self {
-        LowerCtx { hygiene: hygiene.clone(), file_id: None, source_ast_id_map: None }
+        LowerCtx { db, hygiene: hygiene.clone(), file_id: None, source_ast_id_map: None }
    }
    pub(crate) fn hygiene(&self) -> &Hygiene {
@@ -145,7 +147,7 @@ impl ExprCollector<'_> {
        (self.body, self.source_map)
    }
-    fn ctx(&self) -> LowerCtx {
+    fn ctx(&self) -> LowerCtx<'_> {
        LowerCtx::new(self.db, self.expander.current_file_id)
    }
@@ -376,7 +378,7 @@ impl ExprCollector<'_> {
            ast::Expr::PathExpr(e) => {
                let path = e
                    .path()
-                    .and_then(|path| self.expander.parse_path(path))
+                    .and_then(|path| self.expander.parse_path(self.db, path))
                    .map(Expr::Path)
                    .unwrap_or(Expr::Missing);
                self.alloc_expr(path, syntax_ptr)
@@ -408,7 +410,8 @@ impl ExprCollector<'_> {
                self.alloc_expr(Expr::Yield { expr }, syntax_ptr)
            }
            ast::Expr::RecordExpr(e) => {
-                let path = e.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
+                let path =
+                    e.path().and_then(|path| self.expander.parse_path(self.db, path)).map(Box::new);
                let record_lit = if let Some(nfl) = e.record_expr_field_list() {
                    let fields = nfl
                        .fields()
@@ -791,7 +794,8 @@ impl ExprCollector<'_> {
                }
            }
            ast::Pat::TupleStructPat(p) => {
-                let path = p.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
+                let path =
+                    p.path().and_then(|path| self.expander.parse_path(self.db, path)).map(Box::new);
                let (args, ellipsis) = self.collect_tuple_pat(p.fields());
                Pat::TupleStruct { path, args, ellipsis }
            }
@@ -801,7 +805,8 @@ impl ExprCollector<'_> {
                Pat::Ref { pat, mutability }
            }
            ast::Pat::PathPat(p) => {
-                let path = p.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
+                let path =
+                    p.path().and_then(|path| self.expander.parse_path(self.db, path)).map(Box::new);
                path.map(Pat::Path).unwrap_or(Pat::Missing)
            }
            ast::Pat::OrPat(p) => {
@@ -815,7 +820,8 @@ impl ExprCollector<'_> {
            }
            ast::Pat::WildcardPat(_) => Pat::Wild,
            ast::Pat::RecordPat(p) => {
-                let path = p.path().and_then(|path| self.expander.parse_path(path)).map(Box::new);
+                let path =
+                    p.path().and_then(|path| self.expander.parse_path(self.db, path)).map(Box::new);
                let args: Vec<_> = p
                    .record_pat_field_list()
                    .expect("every struct should have a field list")
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index c06a37294..858e88038 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -386,7 +386,7 @@ mod tests {
        let parsed_path_file = syntax::SourceFile::parse(&format!("use {};", path));
        let ast_path =
            parsed_path_file.syntax_node().descendants().find_map(syntax::ast::Path::cast).unwrap();
-        let mod_path = ModPath::from_src(ast_path, &Hygiene::new_unhygienic()).unwrap();
+        let mod_path = ModPath::from_src(&db, ast_path, &Hygiene::new_unhygienic()).unwrap();
        let def_map = module.def_map(&db);
        let resolved = def_map
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index eaeca01bd..8d13c7e04 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -88,7 +88,7 @@ impl ItemTree {
        let mut item_tree = match_ast! {
            match syntax {
                ast::SourceFile(file) => {
-                    top_attrs = Some(RawAttrs::new(&file, &hygiene));
+                    top_attrs = Some(RawAttrs::new(db, &file, &hygiene));
                    ctx.lower_module_items(&file)
                },
                ast::MacroItems(items) => {
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 45b099cf3..5743b3386 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -31,18 +31,20 @@ where
    }
 }
-pub(super) struct Ctx {
+pub(super) struct Ctx<'a> {
+    db: &'a dyn DefDatabase,
    tree: ItemTree,
    hygiene: Hygiene,
    file: HirFileId,
    source_ast_id_map: Arc<AstIdMap>,
-    body_ctx: crate::body::LowerCtx,
+    body_ctx: crate::body::LowerCtx<'a>,
    forced_visibility: Option<RawVisibilityId>,
 }
-impl Ctx {
+impl<'a> Ctx<'a> {
-    pub(super) fn new(db: &dyn DefDatabase, hygiene: Hygiene, file: HirFileId) -> Self {
+    pub(super) fn new(db: &'a dyn DefDatabase, hygiene: Hygiene, file: HirFileId) -> Self {
        Self {
+            db,
            tree: ItemTree::default(),
            hygiene,
            file,
@@ -126,7 +128,7 @@ impl Ctx {
            | ast::Item::MacroDef(_) => {}
        };
-        let attrs = RawAttrs::new(item, &self.hygiene);
+        let attrs = RawAttrs::new(self.db, item, &self.hygiene);
        let items = match item {
            ast::Item::Struct(ast) => self.lower_struct(ast).map(Into::into),
            ast::Item::Union(ast) => self.lower_union(ast).map(Into::into),
@@ -256,7 +258,7 @@ impl Ctx {
        for field in fields.fields() {
            if let Some(data) = self.lower_record_field(&field) {
                let idx = self.data().fields.alloc(data);
-                self.add_attrs(idx.into(), RawAttrs::new(&field, &self.hygiene));
+                self.add_attrs(idx.into(), RawAttrs::new(self.db, &field, &self.hygiene));
            }
        }
        let end = self.next_field_idx();
@@ -276,7 +278,7 @@ impl Ctx {
        for (i, field) in fields.fields().enumerate() {
            let data = self.lower_tuple_field(i, &field);
            let idx = self.data().fields.alloc(data);
-            self.add_attrs(idx.into(), RawAttrs::new(&field, &self.hygiene));
+            self.add_attrs(idx.into(), RawAttrs::new(self.db, &field, &self.hygiene));
        }
        let end = self.next_field_idx();
        IdRange::new(start..end)
@@ -321,7 +323,7 @@ impl Ctx {
        for variant in variants.variants() {
            if let Some(data) = self.lower_variant(&variant) {
                let idx = self.data().variants.alloc(data);
-                self.add_attrs(idx.into(), RawAttrs::new(&variant, &self.hygiene));
+                self.add_attrs(idx.into(), RawAttrs::new(self.db, &variant, &self.hygiene));
            }
        }
        let end = self.next_variant_idx();
@@ -364,7 +366,7 @@ impl Ctx {
                };
                let ty = Interned::new(self_type);
                let idx = self.data().params.alloc(Param::Normal(ty));
-                self.add_attrs(idx.into(), RawAttrs::new(&self_param, &self.hygiene));
+                self.add_attrs(idx.into(), RawAttrs::new(self.db, &self_param, &self.hygiene));
                has_self_param = true;
            }
            for param in param_list.params() {
@@ -376,7 +378,7 @@ impl Ctx {
                        self.data().params.alloc(Param::Normal(ty))
                    }
                };
-                self.add_attrs(idx.into(), RawAttrs::new(&param, &self.hygiene));
+                self.add_attrs(idx.into(), RawAttrs::new(self.db, &param, &self.hygiene));
            }
        }
        let end_param = self.next_param_idx();
@@ -522,10 +524,11 @@ impl Ctx {
        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| {
+            let db = self.db;
            self.with_inherited_visibility(visibility, |this| {
                list.assoc_items()
                    .filter_map(|item| {
-                        let attrs = RawAttrs::new(&item, &this.hygiene);
+                        let attrs = RawAttrs::new(db, &item, &this.hygiene);
                        this.collect_inner_items(item.syntax());
                        this.lower_assoc_item(&item).map(|item| {
                            this.add_attrs(ModItem::from(item).into(), attrs);
@@ -567,7 +570,7 @@ impl Ctx {
            .filter_map(|item| {
                self.collect_inner_items(item.syntax());
                let assoc = self.lower_assoc_item(&item)?;
-                let attrs = RawAttrs::new(&item, &self.hygiene);
+                let attrs = RawAttrs::new(self.db, &item, &self.hygiene);
                self.add_attrs(ModItem::from(assoc).into(), attrs);
                Some(assoc)
            })
@@ -585,6 +588,7 @@ impl Ctx {
        let mut imports = Vec::new();
        let tree = self.tree.data_mut();
        ModPath::expand_use_item(
+            self.db,
            InFile::new(self.file, use_item.clone()),
            &self.hygiene,
            |path, _use_tree, is_glob, alias| {
@@ -618,7 +622,7 @@ impl Ctx {
    }
    fn lower_macro_call(&mut self, m: &ast::MacroCall) -> Option<FileItemTreeId<MacroCall>> {
-        let path = Interned::new(ModPath::from_src(m.path()?, &self.hygiene)?);
+        let path = Interned::new(ModPath::from_src(self.db, m.path()?, &self.hygiene)?);
        let ast_id = self.source_ast_id_map.ast_id(m);
        let res = MacroCall { path, ast_id };
        Some(id(self.data().macro_calls.alloc(res)))
@@ -647,7 +651,7 @@ impl Ctx {
            list.extern_items()
                .filter_map(|item| {
                    self.collect_inner_items(item.syntax());
-                    let attrs = RawAttrs::new(&item, &self.hygiene);
+                    let attrs = RawAttrs::new(self.db, &item, &self.hygiene);
                    let id: ModItem = match item {
                        ast::ExternItem::Fn(ast) => {
                            let func_id = self.lower_function(&ast)?;
@@ -755,7 +759,7 @@ impl Ctx {
    fn lower_visibility(&mut self, item: &impl ast::VisibilityOwner) -> RawVisibilityId {
        let vis = match self.forced_visibility {
            Some(vis) => return vis,
-            None => RawVisibility::from_ast_with_hygiene(item.visibility(), &self.hygiene),
+            None => RawVisibility::from_ast_with_hygiene(self.db, item.visibility(), &self.hygiene),
        };
        self.data().vis.alloc(vis)
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 25694f037..da46f16f7 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -654,7 +654,7 @@ impl AsMacroCall for InFile<&ast::MacroCall> {
    ) -> Result<Result<MacroCallId, ErrorEmitted>, UnresolvedMacro> {
        let ast_id = AstId::new(self.file_id, db.ast_id_map(self.file_id).ast_id(self.value));
        let h = Hygiene::new(db.upcast(), self.file_id);
-        let path = self.value.path().and_then(|path| path::ModPath::from_src(path, &h));
+        let path = self.value.path().and_then(|path| path::ModPath::from_src(db, path, &h));
        let path = match error_sink
            .option(path, || mbe::ExpandError::Other("malformed macro invocation".into()))
@@ -712,7 +712,7 @@ fn macro_call_as_call_id(
            krate,
            macro_call,
            def,
-            &|path: ast::Path| resolver(path::ModPath::from_src(path, &hygiene)?),
+            &|path: ast::Path| resolver(path::ModPath::from_src(db, path, &hygiene)?),
            error_sink,
        )
        .map(MacroCallId::from)
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index ba027c44a..1bc72ec1f 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -599,6 +599,7 @@ mod diagnostics {
                    let mut cur = 0;
                    let mut tree = None;
                    ModPath::expand_use_item(
+                        db,
                        InFile::new(ast.file_id, use_item),
                        &hygiene,
                        |_mod_path, use_tree, _is_glob, _alias| {
diff --git a/crates/hir_def/src/nameres/tests/incremental.rs b/crates/hir_def/src/nameres/tests/incremental.rs
index 509e1bbbc..227ecd162 100644
--- a/crates/hir_def/src/nameres/tests/incremental.rs
+++ b/crates/hir_def/src/nameres/tests/incremental.rs
@@ -105,3 +105,55 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
        assert!(!format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
    }
 }
+#[test]
+fn typing_inside_a_function_should_not_invalidate_expansions() {
+    let (mut db, pos) = TestDB::with_position(
+        r#"
+//- /lib.rs
+macro_rules! m {
+    ($ident:ident) => {
+        fn $ident() { };
+    }
+}
+mod foo;
+//- /foo/mod.rs
+pub mod bar;
+//- /foo/bar.rs
+m!(X);
+fn quux() { 1$0 }
+m!(Y);
+m!(Z);
+"#,
+    );
+    let krate = db.test_crate();
+    {
+        let events = db.log_executed(|| {
+            let crate_def_map = db.crate_def_map(krate);
+            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
+            assert_eq!(module_data.scope.resolutions().count(), 4);
+        });
+        let n_recalculated_item_trees = events.iter().filter(|it| it.contains("item_tree")).count();
+        assert_eq!(n_recalculated_item_trees, 6);
+    }
+    let new_text = r#"
+m!(X);
+fn quux() { 92 }
+m!(Y);
+m!(Z);
+"#;
+    db.set_file_text(pos.file_id, Arc::new(new_text.to_string()));
+    {
+        let events = db.log_executed(|| {
+            let crate_def_map = db.crate_def_map(krate);
+            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
+            assert_eq!(module_data.scope.resolutions().count(), 4);
+        });
+        let n_recalculated_item_trees = events.iter().filter(|it| it.contains("item_tree")).count();
+        assert_eq!(n_recalculated_item_trees, 1);
+    }
+}
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 509f77850..a43441b1c 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -7,7 +7,7 @@ use std::{
    sync::Arc,
 };
-use crate::{body::LowerCtx, intern::Interned, type_ref::LifetimeRef};
+use crate::{body::LowerCtx, db::DefDatabase, intern::Interned, type_ref::LifetimeRef};
 use base_db::CrateId;
 use hir_expand::{
    hygiene::Hygiene,
@@ -47,8 +47,8 @@ pub enum ImportAlias {
 }
 impl ModPath {
-    pub fn from_src(path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
+    pub fn from_src(db: &dyn DefDatabase, path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
-        let ctx = LowerCtx::with_hygiene(hygiene);
+        let ctx = LowerCtx::with_hygiene(db, hygiene);
        lower::lower_path(path, &ctx).map(|it| (*it.mod_path).clone())
    }
@@ -64,12 +64,13 @@ impl ModPath {
    /// Calls `cb` with all paths, represented by this use item.
    pub(crate) fn expand_use_item(
+        db: &dyn DefDatabase,
        item_src: InFile<ast::Use>,
        hygiene: &Hygiene,
        mut cb: impl FnMut(ModPath, &ast::UseTree, /* is_glob */ bool, Option<ImportAlias>),
    ) {
        if let Some(tree) = item_src.value.use_tree() {
-            lower::lower_use_tree(None, tree, hygiene, &mut cb);
+            lower::lower_use_tree(db, None, tree, hygiene, &mut cb);
        }
    }
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index 1df6db525..a873325b2 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -36,7 +36,7 @@ pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx) -> Option<Path> {
        match segment.kind()? {
            ast::PathSegmentKind::Name(name_ref) => {
                // FIXME: this should just return name
-                match hygiene.name_ref_to_name(name_ref) {
+                match hygiene.name_ref_to_name(ctx.db.upcast(), name_ref) {
                    Either::Left(name) => {
                        let args = segment
                            .generic_arg_list()
@@ -133,7 +133,7 @@ pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx) -> Option<Path> {
    // We follow what it did anyway :)
    if segments.len() == 1 && kind == PathKind::Plain {
        if let Some(_macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {
-            if let Some(crate_id) = hygiene.local_inner_macros(path) {
+            if let Some(crate_id) = hygiene.local_inner_macros(ctx.db.upcast(), path) {
                kind = PathKind::DollarCrate(crate_id);
            }
        }
diff --git a/crates/hir_def/src/path/lower/lower_use.rs b/crates/hir_def/src/path/lower/lower_use.rs
index e2965b033..ee80e3df3 100644
--- a/crates/hir_def/src/path/lower/lower_use.rs
+++ b/crates/hir_def/src/path/lower/lower_use.rs
@@ -7,9 +7,13 @@ use either::Either;
 use hir_expand::{hygiene::Hygiene, name::AsName};
 use syntax::ast::{self, NameOwner};
-use crate::path::{ImportAlias, ModPath, PathKind};
+use crate::{
+    db::DefDatabase,
+    path::{ImportAlias, ModPath, PathKind},
+};
 pub(crate) fn lower_use_tree(
+    db: &dyn DefDatabase,
    prefix: Option<ModPath>,
    tree: ast::UseTree,
    hygiene: &Hygiene,
@@ -21,13 +25,13 @@ pub(crate) fn lower_use_tree(
            None => prefix,
            // E.g. `use something::{inner}` (prefix is `None`, path is `something`)
            // or `use something::{path::{inner::{innerer}}}` (prefix is `something::path`, path is `inner`)
-            Some(path) => match convert_path(prefix, path, hygiene) {
+            Some(path) => match convert_path(db, prefix, path, hygiene) {
                Some(it) => Some(it),
                None => return, // FIXME: report errors somewhere
            },
        };
        for child_tree in use_tree_list.use_trees() {
-            lower_use_tree(prefix.clone(), child_tree, hygiene, cb);
+            lower_use_tree(db, prefix.clone(), child_tree, hygiene, cb);
        }
    } else {
        let alias = tree.rename().map(|a| {
@@ -47,7 +51,7 @@ pub(crate) fn lower_use_tree(
                    }
                }
            }
-            if let Some(path) = convert_path(prefix, ast_path, hygiene) {
+            if let Some(path) = convert_path(db, prefix, ast_path, hygiene) {
                cb(path, &tree, is_glob, alias)
            }
        // FIXME: report errors somewhere
@@ -61,9 +65,14 @@ pub(crate) fn lower_use_tree(
    }
 }
-fn convert_path(prefix: Option<ModPath>, path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
+fn convert_path(
+    db: &dyn DefDatabase,
+    prefix: Option<ModPath>,
+    path: ast::Path,
+    hygiene: &Hygiene,
+) -> Option<ModPath> {
    let prefix = if let Some(qual) = path.qualifier() {
-        Some(convert_path(prefix, qual, hygiene)?)
+        Some(convert_path(db, prefix, qual, hygiene)?)
    } else {
        prefix
    };
@@ -71,7 +80,7 @@ fn convert_path(prefix: Option<ModPath>, path: ast::Path, hygiene: &Hygiene) ->
    let segment = path.segment()?;
    let res = match segment.kind()? {
        ast::PathSegmentKind::Name(name_ref) => {
-            match hygiene.name_ref_to_name(name_ref) {
+            match hygiene.name_ref_to_name(db.upcast(), name_ref) {
                Either::Left(name) => {
                    // no type args in use
                    let mut res = prefix.unwrap_or_else(|| {
diff --git a/crates/hir_def/src/visibility.rs b/crates/hir_def/src/visibility.rs
index d4b7c9970..83500f54e 100644
--- a/crates/hir_def/src/visibility.rs
+++ b/crates/hir_def/src/visibility.rs
@@ -33,17 +33,19 @@ impl RawVisibility {
        db: &dyn DefDatabase,
        node: InFile<Option<ast::Visibility>>,
    ) -> RawVisibility {
-        Self::from_ast_with_hygiene(node.value, &Hygiene::new(db.upcast(), node.file_id))
+        Self::from_ast_with_hygiene(db, node.value, &Hygiene::new(db.upcast(), node.file_id))
    }
    pub(crate) fn from_ast_with_hygiene(
+        db: &dyn DefDatabase,
        node: Option<ast::Visibility>,
        hygiene: &Hygiene,
    ) -> RawVisibility {
-        Self::from_ast_with_hygiene_and_default(node, RawVisibility::private(), hygiene)
+        Self::from_ast_with_hygiene_and_default(db, node, RawVisibility::private(), hygiene)
    }
    pub(crate) fn from_ast_with_hygiene_and_default(
+        db: &dyn DefDatabase,
        node: Option<ast::Visibility>,
        default: RawVisibility,
        hygiene: &Hygiene,
@@ -54,7 +56,7 @@ impl RawVisibility {
        };
        match node.kind() {
            ast::VisibilityKind::In(path) => {
-                let path = ModPath::from_src(path, hygiene);
+                let path = ModPath::from_src(db, path, hygiene);
                let path = match path {
                    None => return RawVisibility::private(),
                    Some(path) => path,
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 3e9abd8a1..d61f4b31a 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -283,7 +283,7 @@ fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
    };
    let loc = db.lookup_intern_macro(id);
    let arg = loc.kind.arg(db)?;
-    Some(arg.green())
+    Some(arg.green().into())
 }
 fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<TokenExpander>> {
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index ed61ebca3..aca69e35a 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -32,10 +32,14 @@ impl Hygiene {
    }
    // FIXME: this should just return name
-    pub fn name_ref_to_name(&self, name_ref: ast::NameRef) -> Either<Name, CrateId> {
+    pub fn name_ref_to_name(
+        &self,
+        db: &dyn AstDatabase,
+        name_ref: ast::NameRef,
+    ) -> Either<Name, CrateId> {
        if let Some(frames) = &self.frames {
            if name_ref.text() == "$crate" {
-                if let Some(krate) = frames.root_crate(name_ref.syntax()) {
+                if let Some(krate) = frames.root_crate(db, name_ref.syntax()) {
                    return Either::Right(krate);
                }
            }
@@ -44,15 +48,19 @@ impl Hygiene {
        Either::Left(name_ref.as_name())
    }
-    pub fn local_inner_macros(&self, path: ast::Path) -> Option<CrateId> {
+    pub fn local_inner_macros(&self, db: &dyn AstDatabase, path: ast::Path) -> Option<CrateId> {
        let mut token = path.syntax().first_token()?.text_range();
        let frames = self.frames.as_ref()?;
        let mut current = frames.0.clone();
        loop {
-            let (mapped, origin) = current.expansion.as_ref()?.map_ident_up(token)?;
+            let (mapped, origin) = current.expansion.as_ref()?.map_ident_up(db, token)?;
            if origin == Origin::Def {
-                return if current.local_inner { frames.root_crate(path.syntax()) } else { None };
+                return if current.local_inner {
+                    frames.root_crate(db, path.syntax())
+                } else {
+                    None
+                };
            }
            current = current.call_site.as_ref()?.clone();
            token = mapped.value;
@@ -82,13 +90,13 @@ impl HygieneFrames {
        HygieneFrames(Arc::new(HygieneFrame::new(db, file_id)))
    }
-    fn root_crate(&self, node: &SyntaxNode) -> Option<CrateId> {
+    fn root_crate(&self, db: &dyn AstDatabase, node: &SyntaxNode) -> Option<CrateId> {
        let mut token = node.first_token()?.text_range();
        let mut result = self.0.krate;
        let mut current = self.0.clone();
        while let Some((mapped, origin)) =
-            current.expansion.as_ref().and_then(|it| it.map_ident_up(token))
+            current.expansion.as_ref().and_then(|it| it.map_ident_up(db, token))
        {
            result = current.krate;
@@ -112,7 +120,7 @@ impl HygieneFrames {
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct HygieneInfo {
-    arg_start: InFile<TextSize>,
+    file: MacroFile,
    /// The `macro_rules!` arguments.
    def_start: Option<InFile<TextSize>>,
@@ -122,12 +130,24 @@ struct HygieneInfo {
 }
 impl HygieneInfo {
-    fn map_ident_up(&self, token: TextRange) -> Option<(InFile<TextRange>, Origin)> {
+    fn map_ident_up(
+        &self,
+        db: &dyn AstDatabase,
+        token: TextRange,
+    ) -> Option<(InFile<TextRange>, Origin)> {
        let token_id = self.exp_map.token_by_range(token)?;
        let (token_id, origin) = self.macro_def.map_id_up(token_id);
        let (token_map, tt) = match origin {
-            mbe::Origin::Call => (&self.macro_arg.1, self.arg_start),
+            mbe::Origin::Call => {
+                let call_id = match self.file.macro_call_id {
+                    MacroCallId::LazyMacro(lazy) => lazy,
+                    MacroCallId::EagerMacro(_) => unreachable!(),
+                };
+                let loc: MacroCallLoc = db.lookup_intern_macro(call_id);
+                let arg_start = loc.kind.arg(db)?.text_range().start();
+                (&self.macro_arg.1, InFile::new(loc.kind.file_id(), arg_start))
+            }
            mbe::Origin::Def => match (&*self.macro_def, self.def_start) {
                (TokenExpander::MacroDef { def_site_token_map, .. }, Some(tt))
                | (TokenExpander::MacroRules { def_site_token_map, .. }, Some(tt)) => {
@@ -147,8 +167,6 @@ fn make_hygiene_info(
    macro_file: MacroFile,
    loc: &MacroCallLoc,
 ) -> Option<HygieneInfo> {
-    let arg_tt = loc.kind.arg(db)?;
    let def_offset = loc.def.ast_id().left().and_then(|id| {
        let def_tt = match id.to_node(db) {
            ast::Macro::MacroRules(mac) => mac.token_tree()?.syntax().text_range().start(),
@@ -161,13 +179,7 @@ fn make_hygiene_info(
    let (_, exp_map) = db.parse_macro_expansion(macro_file).value?;
    let macro_arg = db.macro_arg(macro_file.macro_call_id)?;
-    Some(HygieneInfo {
+    Some(HygieneInfo { file: macro_file, def_start: def_offset, macro_arg, macro_def, exp_map })
-        arg_start: InFile::new(loc.kind.file_id(), arg_tt.text_range().start()),
-        def_start: def_offset,
-        macro_arg,
-        macro_def,
-        exp_map,
-    })
 }
 impl HygieneFrame {
@@ -178,7 +190,8 @@ impl HygieneFrame {
                MacroCallId::EagerMacro(_id) => (None, None, false),
                MacroCallId::LazyMacro(id) => {
                    let loc = db.lookup_intern_macro(id);
-                    let info = make_hygiene_info(db, macro_file, &loc);
+                    let info = make_hygiene_info(db, macro_file, &loc)
+                        .map(|info| (loc.kind.file_id(), info));
                    match loc.def.kind {
                        MacroDefKind::Declarative(_) => {
                            (info, Some(loc.def.krate), loc.def.local_inner)
@@ -192,7 +205,7 @@ impl HygieneFrame {
            },
        };
-        let info = match info {
+        let (calling_file, info) = match info {
            None => {
                return HygieneFrame {
                    expansion: None,
@@ -206,7 +219,7 @@ impl HygieneFrame {
        };
        let def_site = info.def_start.map(|it| db.hygiene_frame(it.file_id));
-        let call_site = Some(db.hygiene_frame(info.arg_start.file_id));
+        let call_site = Some(db.hygiene_frame(calling_file));
        HygieneFrame { expansion: Some(info), local_inner, krate, call_site, def_site }
    }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 4fb7d9cf2..1f6edf7a2 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -1000,7 +1000,7 @@ impl HirDisplay for TypeRef {
            }
            TypeRef::Macro(macro_call) => {
                let macro_call = macro_call.to_node(f.db.upcast());
-                let ctx = body::LowerCtx::with_hygiene(&Hygiene::new_unhygienic());
+                let ctx = body::LowerCtx::with_hygiene(f.db.upcast(), &Hygiene::new_unhygienic());
                match macro_call.path() {
                    Some(path) => match Path::from_src(path, &ctx) {
                        Some(path) => path.hir_fmt(f)?,
diff --git a/crates/ide/src/folding_ranges.rs b/crates/ide/src/folding_ranges.rs
index 2b9ed123c..a03988778 100644..100755
--- a/crates/ide/src/folding_ranges.rs
+++ b/crates/ide/src/folding_ranges.rs
@@ -20,6 +20,7 @@ pub enum FoldKind {
    Consts,
    Statics,
    Array,
+    WhereClause,
 }
 #[derive(Debug)]
@@ -109,6 +110,13 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
                        res.push(Fold { range, kind: FoldKind::Statics })
                    }
                }
+                // Fold where clause
+                if node.kind() == WHERE_CLAUSE {
+                    if let Some(range) = fold_range_for_where_clause(&node) {
+                        res.push(Fold { range, kind: FoldKind::WhereClause })
+                    }
+                }
            }
        }
    }
@@ -241,6 +249,23 @@ fn contiguous_range_for_comment(
    }
 }
+fn fold_range_for_where_clause(node: &SyntaxNode) -> Option<TextRange> {
+    let first_where_pred = node.first_child();
+    let last_where_pred = node.last_child();
+    if first_where_pred != last_where_pred {
+        let mut it = node.descendants_with_tokens();
+        if let (Some(_where_clause), Some(where_kw), Some(last_comma)) =
+            (it.next(), it.next(), it.last())
+        {
+            let start = where_kw.text_range().end();
+            let end = last_comma.text_range().end();
+            return Some(TextRange::new(start, end));
+        }
+    }
+    None
+}
 #[cfg(test)]
 mod tests {
    use test_utils::extract_tags;
@@ -272,6 +297,7 @@ mod tests {
                FoldKind::Consts => "consts",
                FoldKind::Statics => "statics",
                FoldKind::Array => "array",
+                FoldKind::WhereClause => "whereclause",
            };
            assert_eq!(kind, &attr.unwrap());
        }
@@ -513,4 +539,23 @@ static SECOND_STATIC: &str = "second";</fold>
            "#,
        )
    }
+    #[test]
+    fn fold_where_clause() {
+        // fold multi-line and don't fold single line.
+        check(
+            r#"
+fn foo()
+where<fold whereclause>
+    A: Foo,
+    B: Foo,
+    C: Foo,
+    D: Foo,</fold> {}
+fn bar()
+where
+    A: Bar, {}
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index d5ef054d8..e0bf660c4 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -218,9 +218,7 @@ fn hint_iterator(
    ty: &hir::Type,
 ) -> Option<SmolStr> {
    let db = sema.db;
-    let strukt = std::iter::successors(Some(ty.clone()), |ty| ty.remove_ref())
+    let strukt = ty.strip_references().as_adt()?;
-        .last()
-        .and_then(|strukt| strukt.as_adt())?;
    let krate = strukt.krate(db);
    if krate != famous_defs.core()? {
        return None;
diff --git a/crates/ide_completion/src/completions.rs b/crates/ide_completion/src/completions.rs
index e2994eed4..78154bf3e 100644
--- a/crates/ide_completion/src/completions.rs
+++ b/crates/ide_completion/src/completions.rs
@@ -203,41 +203,37 @@ impl Completions {
 fn complete_enum_variants(
    acc: &mut Completions,
    ctx: &CompletionContext,
-    ty: &hir::Type,
+    enum_data: hir::Enum,
    cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath),
 ) {
-    if let Some(hir::Adt::Enum(enum_data)) =
+    let variants = enum_data.variants(ctx.db);
-        iter::successors(Some(ty.clone()), |ty| ty.remove_ref()).last().and_then(|ty| ty.as_adt())
-    {
+    let module = if let Some(module) = ctx.scope.module() {
-        let variants = enum_data.variants(ctx.db);
+        // Compute path from the completion site if available.
+        module
-        let module = if let Some(module) = ctx.scope.module() {
+    } else {
-            // Compute path from the completion site if available.
+        // Otherwise fall back to the enum's definition site.
-            module
+        enum_data.module(ctx.db)
-        } else {
+    };
-            // Otherwise fall back to the enum's definition site.
-            enum_data.module(ctx.db)
+    if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
-        };
+        if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_data)) {
+            for &variant in &variants {
-        if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
+                let self_path = hir::ModPath::from_segments(
-            if impl_.self_ty(ctx.db) == *ty {
+                    hir::PathKind::Plain,
-                for &variant in &variants {
+                    iter::once(known::SELF_TYPE).chain(iter::once(variant.name(ctx.db))),
-                    let self_path = hir::ModPath::from_segments(
+                );
-                        hir::PathKind::Plain,
+                cb(acc, ctx, variant, self_path);
-                        iter::once(known::SELF_TYPE).chain(iter::once(variant.name(ctx.db))),
-                    );
-                    cb(acc, ctx, variant, self_path);
-                }
            }
        }
+    }
-        for variant in variants {
+    for variant in variants {
-            if let Some(path) = module.find_use_path(ctx.db, hir::ModuleDef::from(variant)) {
+        if let Some(path) = module.find_use_path(ctx.db, hir::ModuleDef::from(variant)) {
-                // Variants with trivial paths are already added by the existing completion logic,
+            // Variants with trivial paths are already added by the existing completion logic,
-                // so we should avoid adding these twice
+            // so we should avoid adding these twice
-                if path.segments().len() > 1 {
+            if path.segments().len() > 1 {
-                    cb(acc, ctx, variant, path);
+                cb(acc, ctx, variant, path);
-                }
            }
        }
    }
diff --git a/crates/ide_completion/src/completions/pattern.rs b/crates/ide_completion/src/completions/pattern.rs
index 808d7ff7e..8dc9ab73c 100644
--- a/crates/ide_completion/src/completions/pattern.rs
+++ b/crates/ide_completion/src/completions/pattern.rs
@@ -12,8 +12,10 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
    }
    if !ctx.is_irrefutable_pat_binding {
-        if let Some(ty) = ctx.expected_type.as_ref() {
+        if let Some(hir::Adt::Enum(e)) =
-            super::complete_enum_variants(acc, ctx, ty, |acc, ctx, variant, path| {
+            ctx.expected_type.as_ref().and_then(|ty| ty.strip_references().as_adt())
+        {
+            super::complete_enum_variants(acc, ctx, e, |acc, ctx, variant, path| {
                acc.add_qualified_variant_pat(ctx, variant, path.clone());
                acc.add_qualified_enum_variant(ctx, variant, path);
            });
diff --git a/crates/ide_completion/src/completions/postfix.rs b/crates/ide_completion/src/completions/postfix.rs
index ac69b720a..962aaf0df 100644
--- a/crates/ide_completion/src/completions/postfix.rs
+++ b/crates/ide_completion/src/completions/postfix.rs
@@ -35,14 +35,11 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
        None => return,
    };
-    let ref_removed_ty =
-        std::iter::successors(Some(receiver_ty.clone()), |ty| ty.remove_ref()).last().unwrap();
    let cap = match ctx.config.snippet_cap {
        Some(it) => it,
        None => return,
    };
-    let try_enum = TryEnum::from_ty(&ctx.sema, &ref_removed_ty);
+    let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty.strip_references());
    if let Some(try_enum) = &try_enum {
        match try_enum {
            TryEnum::Result => {
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index d2ebba65f..eedb44873 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -59,6 +59,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                hir::ModuleDef::TypeAlias(a) => {
                    let ty = a.ty(ctx.db);
                    if let Some(Adt::Enum(e)) = ty.as_adt() {
+                        cov_mark::hit!(completes_variant_through_alias);
                        add_enum_variants(ctx, acc, e);
                    }
                    ty
@@ -68,6 +69,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                        Some(it) => it,
                        None => return,
                    };
+                    cov_mark::hit!(completes_primitive_assoc_const);
                    builtin.ty(ctx.db, module)
                }
                _ => unreachable!(),
@@ -96,9 +98,8 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                    if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
                        return None;
                    }
-                    match item {
+                    if let hir::AssocItem::TypeAlias(ty) = item {
-                        hir::AssocItem::Function(_) | hir::AssocItem::Const(_) => {}
+                        acc.add_type_alias(ctx, ty)
-                        hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
                    }
                    None::<()>
                });
@@ -745,7 +746,7 @@ fn f() {}
    }
    #[test]
-    fn completes_self_enum() {
+    fn completes_variant_through_self() {
        check(
            r#"
 enum Foo {
@@ -769,6 +770,7 @@ impl Foo {
    #[test]
    fn completes_primitive_assoc_const() {
+        cov_mark::check!(completes_primitive_assoc_const);
        check(
            r#"
 //- /lib.rs crate:lib deps:core
@@ -792,7 +794,8 @@ impl u8 {
    }
    #[test]
-    fn completes_through_alias() {
+    fn completes_variant_through_alias() {
+        cov_mark::check!(completes_variant_through_alias);
        check(
            r#"
 enum Foo {
diff --git a/crates/ide_completion/src/completions/trait_impl.rs b/crates/ide_completion/src/completions/trait_impl.rs
index a26fe7c6c..968c0254d 100644
--- a/crates/ide_completion/src/completions/trait_impl.rs
+++ b/crates/ide_completion/src/completions/trait_impl.rs
@@ -36,7 +36,7 @@ use ide_db::{traits::get_missing_assoc_items, SymbolKind};
 use syntax::{
    ast::{self, edit, Impl},
    display::function_declaration,
-    AstNode, SyntaxKind, SyntaxNode, TextRange, T,
+    AstNode, SyntaxElement, SyntaxKind, SyntaxNode, TextRange, T,
 };
 use text_edit::TextEdit;
@@ -154,8 +154,7 @@ fn add_function_impl(
    } else {
        CompletionItemKind::SymbolKind(SymbolKind::Function)
    };
-    let range = TextRange::new(fn_def_node.text_range().start(), ctx.source_range().end());
+    let range = replacement_range(ctx, fn_def_node);
    if let Some(src) = func.source(ctx.db) {
        let function_decl = function_declaration(&src.value);
        match ctx.config.snippet_cap {
@@ -183,8 +182,7 @@ fn add_type_alias_impl(
    let snippet = format!("type {} = ", alias_name);
-    let range = TextRange::new(type_def_node.text_range().start(), ctx.source_range().end());
+    let range = replacement_range(ctx, type_def_node);
    let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
    item.text_edit(TextEdit::replace(range, snippet))
        .lookup_by(alias_name)
@@ -205,9 +203,7 @@ fn add_const_impl(
        if let Some(source) = const_.source(ctx.db) {
            let snippet = make_const_compl_syntax(&source.value);
-            let range =
+            let range = replacement_range(ctx, const_def_node);
-                TextRange::new(const_def_node.text_range().start(), ctx.source_range().end());
            let mut item =
                CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
            item.text_edit(TextEdit::replace(range, snippet))
@@ -242,6 +238,17 @@ fn make_const_compl_syntax(const_: &ast::Const) -> String {
    format!("{} = ", syntax.trim_end())
 }
+fn replacement_range(ctx: &CompletionContext, item: &SyntaxNode) -> TextRange {
+    let first_child = item
+        .children_with_tokens()
+        .find(|child| {
+            !matches!(child.kind(), SyntaxKind::COMMENT | SyntaxKind::WHITESPACE | SyntaxKind::ATTR)
+        })
+        .unwrap_or_else(|| SyntaxElement::Node(item.clone()));
+    TextRange::new(first_child.text_range().start(), ctx.source_range().end())
+}
 #[cfg(test)]
 mod tests {
    use expect_test::{expect, Expect};
@@ -734,4 +741,50 @@ impl Test for T {{
            test("CONST", "const $0", "const CONST: u16 = ", next_sibling);
        }
    }
+    #[test]
+    fn snippet_does_not_overwrite_comment_or_attr() {
+        let test = |completion: &str, hint: &str, completed: &str| {
+            check_edit(
+                completion,
+                &format!(
+                    r#"
+trait Foo {{
+    type Type;
+    fn function();
+    const CONST: i32 = 0;
+}}
+struct T;
+impl Foo for T {{
+    // Comment
+    #[bar]
+    {}
+}}
+"#,
+                    hint
+                ),
+                &format!(
+                    r#"
+trait Foo {{
+    type Type;
+    fn function();
+    const CONST: i32 = 0;
+}}
+struct T;
+impl Foo for T {{
+    // Comment
+    #[bar]
+    {}
+}}
+"#,
+                    completed
+                ),
+            )
+        };
+        test("function", "fn f$0", "fn function() {\n    $0\n}");
+        test("Type", "type T$0", "type Type = ");
+        test("CONST", "const C$0", "const CONST: i32 = ");
+    }
 }
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index 1b8b063e7..7875500c1 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -17,8 +17,10 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
        return;
    }
-    if let Some(ty) = &ctx.expected_type {
+    if let Some(hir::Adt::Enum(e)) =
-        super::complete_enum_variants(acc, ctx, ty, |acc, ctx, variant, path| {
+        ctx.expected_type.as_ref().and_then(|ty| ty.strip_references().as_adt())
+    {
+        super::complete_enum_variants(acc, ctx, e, |acc, ctx, variant, path| {
            acc.add_qualified_enum_variant(ctx, variant, path)
        });
    }
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index f3fcb712c..62ef40818 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -381,7 +381,7 @@ impl<'a> CompletionContext<'a> {
                        let def = self.sema.to_def(&it);
                        (def.map(|def| def.ret_type(self.db)), None)
                    },
-                    ast::Stmt(it) => (None, None),
+                    ast::Stmt(_it) => (None, None),
                    _ => {
                        match node.parent() {
                            Some(n) => {
diff --git a/crates/ide_db/src/line_index.rs b/crates/ide_db/src/line_index.rs
index 8e9d8cca2..816edfe6a 100644
--- a/crates/ide_db/src/line_index.rs
+++ b/crates/ide_db/src/line_index.rs
@@ -3,7 +3,6 @@
 use std::iter;
 use rustc_hash::FxHashMap;
-use stdx::partition_point;
 use syntax::{TextRange, TextSize};
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -97,7 +96,7 @@ impl LineIndex {
    }
    pub fn line_col(&self, offset: TextSize) -> LineCol {
-        let line = partition_point(&self.newlines, |&it| it <= offset) - 1;
+        let line = self.newlines.partition_point(|&it| it <= offset) - 1;
        let line_start_offset = self.newlines[line];
        let col = offset - line_start_offset;
        LineCol { line: line as u32, col: col.into() }
@@ -118,8 +117,8 @@ impl LineIndex {
    }
    pub fn lines(&self, range: TextRange) -> impl Iterator<Item = TextRange> + '_ {
-        let lo = partition_point(&self.newlines, |&it| it < range.start());
+        let lo = self.newlines.partition_point(|&it| it < range.start());
-        let hi = partition_point(&self.newlines, |&it| it <= range.end());
+        let hi = self.newlines.partition_point(|&it| it <= range.end());
        let all = iter::once(range.start())
            .chain(self.newlines[lo..hi].iter().copied())
            .chain(iter::once(range.end()));
diff --git a/crates/project_model/src/cfg_flag.rs b/crates/project_model/src/cfg_flag.rs
index e92962cf6..bfdfd458f 100644
--- a/crates/project_model/src/cfg_flag.rs
+++ b/crates/project_model/src/cfg_flag.rs
@@ -4,7 +4,6 @@
 use std::str::FromStr;
 use cfg::CfgOptions;
-use stdx::split_once;
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub enum CfgFlag {
@@ -15,7 +14,7 @@ pub enum CfgFlag {
 impl FromStr for CfgFlag {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let res = match split_once(s, '=') {
+        let res = match s.split_once('=') {
            Some((key, value)) => {
                if !(value.starts_with('"') && value.ends_with('"')) {
                    return Err(format!("Invalid cfg ({:?}), value should be in quotes", s));
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 1d27aa7b3..ecf6fd12f 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -524,6 +524,7 @@ pub(crate) fn folding_range(
        | FoldKind::ArgList
        | FoldKind::Consts
        | FoldKind::Statics
+        | FoldKind::WhereClause
        | FoldKind::Array => None,
    };
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index 1b6211044..340fcacfa 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -65,20 +65,6 @@ pub fn replace(buf: &mut String, from: char, to: &str) {
    *buf = buf.replace(from, to)
 }
-// https://github.com/rust-lang/rust/issues/74773
-pub fn split_once(haystack: &str, delim: char) -> Option<(&str, &str)> {
-    let mut split = haystack.splitn(2, delim);
-    let prefix = split.next()?;
-    let suffix = split.next()?;
-    Some((prefix, suffix))
-}
-pub fn rsplit_once(haystack: &str, delim: char) -> Option<(&str, &str)> {
-    let mut split = haystack.rsplitn(2, delim);
-    let suffix = split.next()?;
-    let prefix = split.next()?;
-    Some((prefix, suffix))
-}
 pub fn trim_indent(mut text: &str) -> String {
    if text.starts_with('\n') {
        text = &text[1..];
@@ -89,7 +75,7 @@ pub fn trim_indent(mut text: &str) -> String {
        .map(|it| it.len() - it.trim_start().len())
        .min()
        .unwrap_or(0);
-    lines_with_ends(text)
+    text.split_inclusive('\n')
        .map(
            |line| {
                if line.len() <= indent {
@@ -102,70 +88,12 @@ pub fn trim_indent(mut text: &str) -> String {
        .collect()
 }
-pub fn lines_with_ends(text: &str) -> LinesWithEnds {
-    LinesWithEnds { text }
-}
-pub struct LinesWithEnds<'a> {
-    text: &'a str,
-}
-impl<'a> Iterator for LinesWithEnds<'a> {
-    type Item = &'a str;
-    fn next(&mut self) -> Option<&'a str> {
-        if self.text.is_empty() {
-            return None;
-        }
-        let idx = self.text.find('\n').map_or(self.text.len(), |it| it + 1);
-        let (res, next) = self.text.split_at(idx);
-        self.text = next;
-        Some(res)
-    }
-}
-/// Returns `idx` such that:
-///
-/// ```text
-///     ∀ x in slice[..idx]:  pred(x)
-///  && ∀ x in slice[idx..]: !pred(x)
-/// ```
-///
-/// https://github.com/rust-lang/rust/issues/73831
-pub fn partition_point<T, P>(slice: &[T], mut pred: P) -> usize
-where
-    P: FnMut(&T) -> bool,
-{
-    let mut left = 0;
-    let mut right = slice.len();
-    while left != right {
-        let mid = left + (right - left) / 2;
-        // SAFETY:
-        // When left < right, left <= mid < right.
-        // Therefore left always increases and right always decreases,
-        // and either of them is selected.
-        // In both cases left <= right is satisfied.
-        // Therefore if left < right in a step,
-        // left <= right is satisfied in the next step.
-        // Therefore as long as left != right, 0 <= left < right <= len is satisfied
-        // and if this case 0 <= mid < len is satisfied too.
-        let value = unsafe { slice.get_unchecked(mid) };
-        if pred(value) {
-            left = mid + 1;
-        } else {
-            right = mid;
-        }
-    }
-    left
-}
 pub fn equal_range_by<T, F>(slice: &[T], mut key: F) -> ops::Range<usize>
 where
    F: FnMut(&T) -> Ordering,
 {
-    let start = partition_point(slice, |it| key(it) == Ordering::Less);
+    let start = slice.partition_point(|it| key(it) == Ordering::Less);
-    let len = partition_point(&slice[start..], |it| key(it) == Ordering::Equal);
+    let len = slice[start..].partition_point(|it| key(it) == Ordering::Equal);
    start..start + len
 }
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index 556f80882..c0bc59918 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 cov-mark = { version = "1.1", features = ["thread-local"] }
 itertools = "0.10.0"
-rowan = "=0.13.0-pre.3"
+rowan = "=0.13.0-pre.5"
 rustc_lexer = { version = "716.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.7"
diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index c9229c4e0..ba263be0d 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -555,7 +555,7 @@ impl SyntaxRewriter<'_> {
 fn element_to_green(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
    match element {
-        NodeOrToken::Node(it) => NodeOrToken::Node(it.green()),
+        NodeOrToken::Node(it) => NodeOrToken::Node(it.green().into_owned()),
        NodeOrToken::Token(it) => NodeOrToken::Token(it.green().to_owned()),
    }
 }
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 42da09606..4bcea28cc 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -572,7 +572,7 @@ fn ast_from_text<N: AstNode>(text: &str) -> N {
 }
 fn unroot(n: SyntaxNode) -> SyntaxNode {
-    SyntaxNode::new_root(n.green())
+    SyntaxNode::new_root(n.green().into())
 }
 pub mod tokens {
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index 492fbc4a0..bef49238f 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -1,30 +1,31 @@
 //! Various extension methods to ast Nodes, which are hard to code-generate.
 //! Extensions for various expressions live in a sibling `expr_extensions` module.
-use std::{fmt, iter::successors};
+use std::{borrow::Cow, fmt, iter::successors};
 use itertools::Itertools;
 use parser::SyntaxKind;
+use rowan::{GreenNodeData, GreenTokenData};
 use crate::{
    ast::{self, support, AstNode, AstToken, AttrsOwner, NameOwner, SyntaxNode},
-    SmolStr, SyntaxElement, SyntaxToken, TokenText, T,
+    NodeOrToken, SmolStr, SyntaxElement, SyntaxToken, TokenText, T,
 };
 impl ast::Lifetime {
-    pub fn text(&self) -> TokenText {
+    pub fn text(&self) -> TokenText<'_> {
        text_of_first_token(self.syntax())
    }
 }
 impl ast::Name {
-    pub fn text(&self) -> TokenText {
+    pub fn text(&self) -> TokenText<'_> {
        text_of_first_token(self.syntax())
    }
 }
 impl ast::NameRef {
-    pub fn text(&self) -> TokenText {
+    pub fn text(&self) -> TokenText<'_> {
        text_of_first_token(self.syntax())
    }
@@ -33,11 +34,15 @@ impl ast::NameRef {
    }
 }
-fn text_of_first_token(node: &SyntaxNode) -> TokenText {
+fn text_of_first_token(node: &SyntaxNode) -> TokenText<'_> {
-    let first_token =
+    fn first_token(green_ref: &GreenNodeData) -> &GreenTokenData {
-        node.green().children().next().and_then(|it| it.into_token()).unwrap().to_owned();
+        green_ref.children().next().and_then(NodeOrToken::into_token).unwrap()
+    }
-    TokenText(first_token)
+    match node.green() {
+        Cow::Borrowed(green_ref) => TokenText::borrowed(first_token(green_ref).text()),
+        Cow::Owned(green) => TokenText::owned(first_token(&green).to_owned()),
+    }
 }
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -412,7 +417,7 @@ impl fmt::Display for NameOrNameRef {
 }
 impl NameOrNameRef {
-    pub fn text(&self) -> TokenText {
+    pub fn text(&self) -> TokenText<'_> {
        match self {
            NameOrNameRef::Name(name) => name.text(),
            NameOrNameRef::NameRef(name_ref) => name_ref.text(),
diff --git a/crates/syntax/src/token_text.rs b/crates/syntax/src/token_text.rs
index d2ed0a12a..f3e8b321a 100644
--- a/crates/syntax/src/token_text.rs
+++ b/crates/syntax/src/token_text.rs
@@ -2,75 +2,93 @@
 use std::{cmp::Ordering, fmt, ops};
-pub struct TokenText(pub(crate) rowan::GreenToken);
+use rowan::GreenToken;
+pub struct TokenText<'a>(pub(crate) Repr<'a>);
+pub(crate) enum Repr<'a> {
+    Borrowed(&'a str),
+    Owned(GreenToken),
+}
+impl<'a> TokenText<'a> {
+    pub(crate) fn borrowed(text: &'a str) -> Self {
+        TokenText(Repr::Borrowed(text))
+    }
+    pub(crate) fn owned(green: GreenToken) -> Self {
+        TokenText(Repr::Owned(green))
+    }
-impl TokenText {
    pub fn as_str(&self) -> &str {
-        self.0.text()
+        match self.0 {
+            Repr::Borrowed(it) => it,
+            Repr::Owned(ref green) => green.text(),
+        }
    }
 }
-impl ops::Deref for TokenText {
+impl ops::Deref for TokenText<'_> {
    type Target = str;
    fn deref(&self) -> &str {
        self.as_str()
    }
 }
-impl AsRef<str> for TokenText {
+impl AsRef<str> for TokenText<'_> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
 }
-impl From<TokenText> for String {
+impl From<TokenText<'_>> for String {
    fn from(token_text: TokenText) -> Self {
        token_text.as_str().into()
    }
 }
-impl PartialEq<&'_ str> for TokenText {
+impl PartialEq<&'_ str> for TokenText<'_> {
    fn eq(&self, other: &&str) -> bool {
        self.as_str() == *other
    }
 }
-impl PartialEq<TokenText> for &'_ str {
+impl PartialEq<TokenText<'_>> for &'_ str {
    fn eq(&self, other: &TokenText) -> bool {
        other == self
    }
 }
-impl PartialEq<String> for TokenText {
+impl PartialEq<String> for TokenText<'_> {
    fn eq(&self, other: &String) -> bool {
        self.as_str() == other.as_str()
    }
 }
-impl PartialEq<TokenText> for String {
+impl PartialEq<TokenText<'_>> for String {
    fn eq(&self, other: &TokenText) -> bool {
        other == self
    }
 }
-impl PartialEq for TokenText {
+impl PartialEq for TokenText<'_> {
    fn eq(&self, other: &TokenText) -> bool {
        self.as_str() == other.as_str()
    }
 }
-impl Eq for TokenText {}
+impl Eq for TokenText<'_> {}
-impl Ord for TokenText {
+impl Ord for TokenText<'_> {
    fn cmp(&self, other: &Self) -> Ordering {
        self.as_str().cmp(other.as_str())
    }
 }
-impl PartialOrd for TokenText {
+impl PartialOrd for TokenText<'_> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
 }
-impl fmt::Display for TokenText {
+impl fmt::Display for TokenText<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(self.as_str(), f)
    }
 }
-impl fmt::Debug for TokenText {
+impl fmt::Debug for TokenText<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(self.as_str(), f)
    }
diff --git a/crates/test_utils/src/fixture.rs b/crates/test_utils/src/fixture.rs
index 099baeca2..d0bddf7d8 100644
--- a/crates/test_utils/src/fixture.rs
+++ b/crates/test_utils/src/fixture.rs
@@ -62,7 +62,7 @@
 //! ```
 use rustc_hash::FxHashMap;
-use stdx::{lines_with_ends, split_once, trim_indent};
+use stdx::trim_indent;
 #[derive(Debug, Eq, PartialEq)]
 pub struct Fixture {
@@ -93,7 +93,7 @@ impl Fixture {
        let default = if ra_fixture.contains("//-") { None } else { Some("//- /main.rs") };
-        for (ix, line) in default.into_iter().chain(lines_with_ends(&fixture)).enumerate() {
+        for (ix, line) in default.into_iter().chain(fixture.split_inclusive('\n')).enumerate() {
            if line.contains("//-") {
                assert!(
                    line.starts_with("//-"),
@@ -133,14 +133,14 @@ impl Fixture {
        let mut env = FxHashMap::default();
        let mut introduce_new_source_root = false;
        for component in components[1..].iter() {
-            let (key, value) = split_once(component, ':').unwrap();
+            let (key, value) = component.split_once(':').unwrap();
            match key {
                "crate" => krate = Some(value.to_string()),
                "deps" => deps = value.split(',').map(|it| it.to_string()).collect(),
                "edition" => edition = Some(value.to_string()),
                "cfg" => {
                    for entry in value.split(',') {
-                        match split_once(entry, '=') {
+                        match entry.split_once('=') {
                            Some((k, v)) => cfg_key_values.push((k.to_string(), v.to_string())),
                            None => cfg_atoms.push(entry.to_string()),
                        }
@@ -148,7 +148,7 @@ impl Fixture {
                }
                "env" => {
                    for key in value.split(',') {
-                        if let Some((k, v)) = split_once(key, '=') {
+                        if let Some((k, v)) = key.split_once('=') {
                            env.insert(k.into(), v.into());
                        }
                    }
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index 72466c957..fce4fd6bf 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -17,7 +17,7 @@ use std::{
 };
 use profile::StopWatch;
-use stdx::{is_ci, lines_with_ends};
+use stdx::is_ci;
 use text_size::{TextRange, TextSize};
 pub use dissimilar::diff as __diff;
@@ -181,7 +181,7 @@ pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
    let mut prev_line_start: Option<TextSize> = None;
    let mut line_start: TextSize = 0.into();
    let mut prev_line_annotations: Vec<(TextSize, usize)> = Vec::new();
-    for line in lines_with_ends(text) {
+    for line in text.split_inclusive('\n') {
        let mut this_line_annotations = Vec::new();
        if let Some(idx) = line.find("//") {
            let annotation_offset = TextSize::of(&line[..idx + "//".len()]);
diff --git a/docs/dev/style.md b/docs/dev/style.md
index 00de7a711..d24a5952e 100644
--- a/docs/dev/style.md
+++ b/docs/dev/style.md
@@ -947,4 +947,4 @@ match p.current() {
 For `.md` and `.adoc` files, prefer a sentence-per-line format, don't wrap lines.
 If the line is too long, you want to split the sentence in two :-)
-**Rationale:** much easier to edit the text and read the diff.
+**Rationale:** much easier to edit the text and read the diff, see [this link](https://asciidoctor.org/docs/asciidoc-recommended-practices/#one-sentence-per-line).
diff --git a/xtask/src/install.rs b/xtask/src/install.rs
index 91d6a2853..7e2dccdfe 100644
--- a/xtask/src/install.rs
+++ b/xtask/src/install.rs
@@ -8,7 +8,7 @@ use xshell::{cmd, pushd};
 use crate::flags;
 // Latest stable, feel free to send a PR if this lags behind.
-const REQUIRED_RUST_VERSION: u32 = 51;
+const REQUIRED_RUST_VERSION: u32 = 52;
 impl flags::Install {
    pub(crate) fn run(self) -> Result<()> {