58 files changed, 2364 insertions, 501 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 49022502d..a1786d201 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -162,9 +162,9 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 [[package]]
 name = "chalk-derive"
-version = "0.30.0"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6696d18587b7470c1e357a3fa120a2b7e6ac95e91d5c408f087455f7dc31f8b"
+checksum = "2d072b2ba723f0bada7c515d8b3725224bc4f5052d2a92dcbeb0b118ff37084a"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -174,9 +174,9 @@ dependencies = [
 [[package]]
 name = "chalk-ir"
-version = "0.30.0"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9538918d3e1fd6edda042d717c969a4099af67a40372dfb0a00b45d3a5a946"
+checksum = "f60cdb0e18c5455cb6a85e8464aad3622b70476018edfa8845691df66f7e9a05"
 dependencies = [
 "chalk-derive",
 "lazy_static",
@@ -184,9 +184,9 @@ dependencies = [
 [[package]]
 name = "chalk-recursive"
-version = "0.30.0"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97ec8d95c808f2b540c39da889536e1ae0d15182107f61fe80000ec3a5c3959a"
+checksum = "b14f40242102e7c0e2791a2cc86dbbc213a1d7b7acc0e22b7da329f4957d1722"
 dependencies = [
 "chalk-derive",
 "chalk-ir",
@@ -197,9 +197,9 @@ dependencies = [
 [[package]]
 name = "chalk-solve"
-version = "0.30.0"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f373dff4bcff66004424b72bcc56ae62889c21887c1cac875f083f69a7da4448"
+checksum = "981534d499a8476ecc0b520be4d3864757f96211826a75360fbf2cb6fae362ab"
 dependencies = [
 "chalk-derive",
 "chalk-ir",
diff --git a/PRIVACY.md b/PRIVACY.md
new file mode 100644
index 000000000..dd165c0e2
--- /dev/null
+++ b/PRIVACY.md
@@ -0,0 +1,17 @@
+# Privacy Notes
+## LSP server binary
+The LSP server performs no network access in itself, but runs `cargo metadata` which will update or download the crate registry and the source code of the project dependencies.
+## Visual Studio Code extension
+The Code extension connects to GitHub to download updated LSP binaries and, if the nightly channel is selected, to perform update checks.
+## Other editor plugins
+Any other editor plugins that integrate with `rust-analyzer` are not under the control of the `rust-analyzer` developers. For any privacy concerns, you should check with their respective developers.
+## Others
+If `cargo check` is enabled (the default), any build scripts or procedural macros used by the project or its dependencies will be executed. This is also the case when `cargo check` is disabled, but build script or procedural macro support is enabled in `rust-analyzer` (off by default).
diff --git a/crates/assists/src/assist_config.rs b/crates/assists/src/assist_config.rs
index adf02edab..b24527ec4 100644
--- a/crates/assists/src/assist_config.rs
+++ b/crates/assists/src/assist_config.rs
@@ -4,6 +4,8 @@
 //! module, and we use to statically check that we only produce snippet
 //! assists if we are allowed to.
+use hir::PrefixKind;
 use crate::{utils::MergeBehaviour, AssistKind};
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -37,10 +39,11 @@ impl Default for AssistConfig {
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct InsertUseConfig {
    pub merge: Option<MergeBehaviour>,
+    pub prefix_kind: PrefixKind,
 }
 impl Default for InsertUseConfig {
    fn default() -> Self {
-        InsertUseConfig { merge: Some(MergeBehaviour::Full) }
+        InsertUseConfig { merge: Some(MergeBehaviour::Full), prefix_kind: PrefixKind::Plain }
    }
 }
diff --git a/crates/assists/src/ast_transform.rs b/crates/assists/src/ast_transform.rs
index 4307e0191..ac72f3f02 100644
--- a/crates/assists/src/ast_transform.rs
+++ b/crates/assists/src/ast_transform.rs
@@ -1,13 +1,14 @@
 //! `AstTransformer`s are functions that replace nodes in an AST and can be easily combined.
-use rustc_hash::FxHashMap;
 use hir::{HirDisplay, PathResolution, SemanticsScope};
+use rustc_hash::FxHashMap;
 use syntax::{
    algo::SyntaxRewriter,
    ast::{self, AstNode},
    SyntaxNode,
 };
+use crate::utils::mod_path_to_ast;
 pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
    SyntaxRewriter::from_fn(|element| match element {
        syntax::SyntaxElement::Node(n) => {
@@ -189,7 +190,7 @@ impl<'a> AstTransform<'a> for QualifyPaths<'a> {
        match resolution {
            PathResolution::Def(def) => {
                let found_path = from.find_use_path(self.source_scope.db.upcast(), def)?;
-                let mut path = path_to_ast(found_path);
+                let mut path = mod_path_to_ast(&found_path);
                let type_args = p
                    .segment()
@@ -210,13 +211,3 @@ impl<'a> AstTransform<'a> for QualifyPaths<'a> {
        }
    }
 }
-pub(crate) fn path_to_ast(path: hir::ModPath) -> ast::Path {
-    let parse = ast::SourceFile::parse(&path.to_string());
-    parse
-        .tree()
-        .syntax()
-        .descendants()
-        .find_map(ast::Path::cast)
-        .unwrap_or_else(|| panic!("failed to parse path {:?}, `{}`", path, path))
-}
diff --git a/crates/assists/src/handlers/add_missing_impl_members.rs b/crates/assists/src/handlers/add_missing_impl_members.rs
index 51b5a2eb0..4c400f287 100644
--- a/crates/assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/assists/src/handlers/add_missing_impl_members.rs
@@ -820,4 +820,29 @@ impl Tr for () {
 }"#,
        )
    }
+    #[test]
+    fn weird_path() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Test {
+    fn foo(&self, x: crate)
+}
+impl Test for () {
+    <|>
+}
+"#,
+            r#"
+trait Test {
+    fn foo(&self, x: crate)
+}
+impl Test for () {
+    fn foo(&self, x: crate) {
+        ${0:todo!()}
+    }
+}
+"#,
+        )
+    }
 }
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index fa524ffd9..d3ee98e5f 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -13,7 +13,10 @@ use syntax::{
    SyntaxNode,
 };
-use crate::{utils::insert_use, AssistContext, AssistId, AssistKind, Assists, GroupLabel};
+use crate::{
+    utils::insert_use, utils::mod_path_to_ast, AssistContext, AssistId, AssistKind, Assists,
+    GroupLabel,
+};
 // Assist: auto_import
 //
@@ -54,7 +57,7 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
            range,
            |builder| {
                let new_syntax =
-                    insert_use(&scope, import.to_ast_path(), ctx.config.insert_use.merge);
+                    insert_use(&scope, mod_path_to_ast(&import), ctx.config.insert_use.merge);
                builder.replace(syntax.text_range(), new_syntax.to_string())
            },
        );
@@ -191,12 +194,16 @@ impl AutoImportAssets {
                _ => Some(candidate),
            })
            .filter_map(|candidate| match candidate {
-                Either::Left(module_def) => {
+                Either::Left(module_def) => self.module_with_name_to_import.find_use_path_prefixed(
-                    self.module_with_name_to_import.find_use_path_prefixed(db, module_def)
+                    db,
-                }
+                    module_def,
-                Either::Right(macro_def) => {
+                    ctx.config.insert_use.prefix_kind,
-                    self.module_with_name_to_import.find_use_path_prefixed(db, macro_def)
+                ),
-                }
+                Either::Right(macro_def) => self.module_with_name_to_import.find_use_path_prefixed(
+                    db,
+                    macro_def,
+                    ctx.config.insert_use.prefix_kind,
+                ),
            })
            .filter(|use_path| !use_path.segments.is_empty())
            .take(20)
diff --git a/crates/assists/src/handlers/convert_integer_literal.rs b/crates/assists/src/handlers/convert_integer_literal.rs
new file mode 100644
index 000000000..ea35e833a
--- /dev/null
+++ b/crates/assists/src/handlers/convert_integer_literal.rs
@@ -0,0 +1,701 @@
+use syntax::{ast, AstNode, SmolStr};
+use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel};
+// Assist: convert_integer_literal
+//
+// Converts the base of integer literals to other bases.
+//
+// ```
+// const _: i32 = 10<|>;
+// ```
+// ->
+// ```
+// const _: i32 = 0b1010;
+// ```
+pub(crate) fn convert_integer_literal(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let literal = ctx.find_node_at_offset::<ast::Literal>()?;
+    let range = literal.syntax().text_range();
+    let group_id = GroupLabel("Convert integer base".into());
+    let suffix = match literal.kind() {
+        ast::LiteralKind::IntNumber { suffix } => suffix,
+        _ => return None,
+    };
+    let suffix_len = suffix.as_ref().map(|s| s.len()).unwrap_or(0);
+    let raw_literal_text = literal.syntax().to_string();
+    // Gets the literal's text without the type suffix and without underscores.
+    let literal_text = raw_literal_text
+        .chars()
+        .take(raw_literal_text.len() - suffix_len)
+        .filter(|c| *c != '_')
+        .collect::<SmolStr>();
+    let literal_base = IntegerLiteralBase::identify(&literal_text)?;
+    for base in IntegerLiteralBase::bases() {
+        if *base == literal_base {
+            continue;
+        }
+        let mut converted = literal_base.convert(&literal_text, base);
+        let label = if let Some(suffix) = &suffix {
+            format!("Convert {} ({}) to {}", &literal_text, suffix, &converted)
+        } else {
+            format!("Convert {} to {}", &literal_text, &converted)
+        };
+        // Appends the type suffix back into the new literal if it exists.
+        if let Some(suffix) = &suffix {
+            converted.push_str(&suffix);
+        }
+        acc.add_group(
+            &group_id,
+            AssistId("convert_integer_literal", AssistKind::RefactorInline),
+            label,
+            range,
+            |builder| builder.replace(range, converted),
+        );
+    }
+    Some(())
+}
+#[derive(Debug, PartialEq, Eq)]
+enum IntegerLiteralBase {
+    Binary,
+    Octal,
+    Decimal,
+    Hexadecimal,
+}
+impl IntegerLiteralBase {
+    fn identify(literal_text: &str) -> Option<Self> {
+        // We cannot express a literal in anything other than decimal in under 3 characters, so we return here if possible.
+        if literal_text.len() < 3 && literal_text.chars().all(|c| c.is_digit(10)) {
+            return Some(Self::Decimal);
+        }
+        let base = match &literal_text[..2] {
+            "0b" => Self::Binary,
+            "0o" => Self::Octal,
+            "0x" => Self::Hexadecimal,
+            _ => Self::Decimal,
+        };
+        // Checks that all characters after the base prefix are all valid digits for that base.
+        if literal_text[base.prefix_len()..].chars().all(|c| c.is_digit(base.base())) {
+            Some(base)
+        } else {
+            None
+        }
+    }
+    fn convert(&self, literal_text: &str, to: &IntegerLiteralBase) -> String {
+        let digits = &literal_text[self.prefix_len()..];
+        let value = u128::from_str_radix(digits, self.base()).unwrap();
+        match to {
+            Self::Binary => format!("0b{:b}", value),
+            Self::Octal => format!("0o{:o}", value),
+            Self::Decimal => value.to_string(),
+            Self::Hexadecimal => format!("0x{:X}", value),
+        }
+    }
+    const fn base(&self) -> u32 {
+        match self {
+            Self::Binary => 2,
+            Self::Octal => 8,
+            Self::Decimal => 10,
+            Self::Hexadecimal => 16,
+        }
+    }
+    const fn prefix_len(&self) -> usize {
+        match self {
+            Self::Decimal => 0,
+            _ => 2,
+        }
+    }
+    const fn bases() -> &'static [IntegerLiteralBase] {
+        &[
+            IntegerLiteralBase::Binary,
+            IntegerLiteralBase::Octal,
+            IntegerLiteralBase::Decimal,
+            IntegerLiteralBase::Hexadecimal,
+        ]
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::tests::{check_assist_by_label, check_assist_target};
+    #[test]
+    fn binary_target() {
+        check_assist_target(convert_integer_literal, "const _: i32 = 0b1010<|>;", "0b1010");
+    }
+    #[test]
+    fn octal_target() {
+        check_assist_target(convert_integer_literal, "const _: i32 = 0o12<|>;", "0o12");
+    }
+    #[test]
+    fn decimal_target() {
+        check_assist_target(convert_integer_literal, "const _: i32 = 10<|>;", "10");
+    }
+    #[test]
+    fn hexadecimal_target() {
+        check_assist_target(convert_integer_literal, "const _: i32 = 0xA<|>;", "0xA");
+    }
+    #[test]
+    fn binary_target_with_underscores() {
+        check_assist_target(convert_integer_literal, "const _: i32 = 0b10_10<|>;", "0b10_10");
+    }
+    #[test]
+    fn octal_target_with_underscores() {
+        check_assist_target(convert_integer_literal, "const _: i32 = 0o1_2<|>;", "0o1_2");
+    }
+    #[test]
+    fn decimal_target_with_underscores() {
+        check_assist_target(convert_integer_literal, "const _: i32 = 1_0<|>;", "1_0");
+    }
+    #[test]
+    fn hexadecimal_target_with_underscores() {
+        check_assist_target(convert_integer_literal, "const _: i32 = 0x_A<|>;", "0x_A");
+    }
+    #[test]
+    fn convert_decimal_integer() {
+        let before = "const _: i32 = 1000<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b1111101000;",
+            "Convert 1000 to 0b1111101000",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o1750;",
+            "Convert 1000 to 0o1750",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0x3E8;",
+            "Convert 1000 to 0x3E8",
+        );
+    }
+    // Decimal numbers under 3 digits have a special case where they return early because we can't fit a
+    // other base's prefix, so we have a separate test for that.
+    #[test]
+    fn convert_small_decimal_integer() {
+        let before = "const _: i32 = 10<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b1010;",
+            "Convert 10 to 0b1010",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o12;",
+            "Convert 10 to 0o12",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xA;",
+            "Convert 10 to 0xA",
+        );
+    }
+    #[test]
+    fn convert_hexadecimal_integer() {
+        let before = "const _: i32 = 0xFF<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b11111111;",
+            "Convert 0xFF to 0b11111111",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o377;",
+            "Convert 0xFF to 0o377",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255;",
+            "Convert 0xFF to 255",
+        );
+    }
+    #[test]
+    fn convert_binary_integer() {
+        let before = "const _: i32 = 0b11111111<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o377;",
+            "Convert 0b11111111 to 0o377",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255;",
+            "Convert 0b11111111 to 255",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xFF;",
+            "Convert 0b11111111 to 0xFF",
+        );
+    }
+    #[test]
+    fn convert_octal_integer() {
+        let before = "const _: i32 = 0o377<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b11111111;",
+            "Convert 0o377 to 0b11111111",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255;",
+            "Convert 0o377 to 255",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xFF;",
+            "Convert 0o377 to 0xFF",
+        );
+    }
+    #[test]
+    fn convert_decimal_integer_with_underscores() {
+        let before = "const _: i32 = 1_00_0<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b1111101000;",
+            "Convert 1000 to 0b1111101000",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o1750;",
+            "Convert 1000 to 0o1750",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0x3E8;",
+            "Convert 1000 to 0x3E8",
+        );
+    }
+    #[test]
+    fn convert_small_decimal_integer_with_underscores() {
+        let before = "const _: i32 = 1_0<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b1010;",
+            "Convert 10 to 0b1010",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o12;",
+            "Convert 10 to 0o12",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xA;",
+            "Convert 10 to 0xA",
+        );
+    }
+    #[test]
+    fn convert_hexadecimal_integer_with_underscores() {
+        let before = "const _: i32 = 0x_F_F<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b11111111;",
+            "Convert 0xFF to 0b11111111",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o377;",
+            "Convert 0xFF to 0o377",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255;",
+            "Convert 0xFF to 255",
+        );
+    }
+    #[test]
+    fn convert_binary_integer_with_underscores() {
+        let before = "const _: i32 = 0b1111_1111<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o377;",
+            "Convert 0b11111111 to 0o377",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255;",
+            "Convert 0b11111111 to 255",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xFF;",
+            "Convert 0b11111111 to 0xFF",
+        );
+    }
+    #[test]
+    fn convert_octal_integer_with_underscores() {
+        let before = "const _: i32 = 0o3_77<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b11111111;",
+            "Convert 0o377 to 0b11111111",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255;",
+            "Convert 0o377 to 255",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xFF;",
+            "Convert 0o377 to 0xFF",
+        );
+    }
+    #[test]
+    fn convert_decimal_integer_with_suffix() {
+        let before = "const _: i32 = 1000i32<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b1111101000i32;",
+            "Convert 1000 (i32) to 0b1111101000",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o1750i32;",
+            "Convert 1000 (i32) to 0o1750",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0x3E8i32;",
+            "Convert 1000 (i32) to 0x3E8",
+        );
+    }
+    #[test]
+    fn convert_small_decimal_integer_with_suffix() {
+        let before = "const _: i32 = 10i32<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b1010i32;",
+            "Convert 10 (i32) to 0b1010",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o12i32;",
+            "Convert 10 (i32) to 0o12",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xAi32;",
+            "Convert 10 (i32) to 0xA",
+        );
+    }
+    #[test]
+    fn convert_hexadecimal_integer_with_suffix() {
+        let before = "const _: i32 = 0xFFi32<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b11111111i32;",
+            "Convert 0xFF (i32) to 0b11111111",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o377i32;",
+            "Convert 0xFF (i32) to 0o377",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255i32;",
+            "Convert 0xFF (i32) to 255",
+        );
+    }
+    #[test]
+    fn convert_binary_integer_with_suffix() {
+        let before = "const _: i32 = 0b11111111i32<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o377i32;",
+            "Convert 0b11111111 (i32) to 0o377",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255i32;",
+            "Convert 0b11111111 (i32) to 255",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xFFi32;",
+            "Convert 0b11111111 (i32) to 0xFF",
+        );
+    }
+    #[test]
+    fn convert_octal_integer_with_suffix() {
+        let before = "const _: i32 = 0o377i32<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b11111111i32;",
+            "Convert 0o377 (i32) to 0b11111111",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255i32;",
+            "Convert 0o377 (i32) to 255",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xFFi32;",
+            "Convert 0o377 (i32) to 0xFF",
+        );
+    }
+    #[test]
+    fn convert_decimal_integer_with_underscores_and_suffix() {
+        let before = "const _: i32 = 1_00_0i32<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b1111101000i32;",
+            "Convert 1000 (i32) to 0b1111101000",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o1750i32;",
+            "Convert 1000 (i32) to 0o1750",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0x3E8i32;",
+            "Convert 1000 (i32) to 0x3E8",
+        );
+    }
+    #[test]
+    fn convert_small_decimal_integer_with_underscores_and_suffix() {
+        let before = "const _: i32 = 1_0i32<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b1010i32;",
+            "Convert 10 (i32) to 0b1010",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o12i32;",
+            "Convert 10 (i32) to 0o12",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xAi32;",
+            "Convert 10 (i32) to 0xA",
+        );
+    }
+    #[test]
+    fn convert_hexadecimal_integer_with_underscores_and_suffix() {
+        let before = "const _: i32 = 0x_F_Fi32<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b11111111i32;",
+            "Convert 0xFF (i32) to 0b11111111",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o377i32;",
+            "Convert 0xFF (i32) to 0o377",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255i32;",
+            "Convert 0xFF (i32) to 255",
+        );
+    }
+    #[test]
+    fn convert_binary_integer_with_underscores_and_suffix() {
+        let before = "const _: i32 = 0b1111_1111i32<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0o377i32;",
+            "Convert 0b11111111 (i32) to 0o377",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255i32;",
+            "Convert 0b11111111 (i32) to 255",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xFFi32;",
+            "Convert 0b11111111 (i32) to 0xFF",
+        );
+    }
+    #[test]
+    fn convert_octal_integer_with_underscores_and_suffix() {
+        let before = "const _: i32 = 0o3_77i32<|>;";
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0b11111111i32;",
+            "Convert 0o377 (i32) to 0b11111111",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 255i32;",
+            "Convert 0o377 (i32) to 255",
+        );
+        check_assist_by_label(
+            convert_integer_literal,
+            before,
+            "const _: i32 = 0xFFi32;",
+            "Convert 0o377 (i32) to 0xFF",
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index f5f03ef36..7f4f80b23 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -10,9 +10,10 @@ use syntax::{
 };
 use crate::{
-    assist_context::AssistBuilder, utils::insert_use, AssistContext, AssistId, AssistKind, Assists,
+    assist_context::AssistBuilder,
+    utils::{insert_use, mod_path_to_ast, ImportScope},
+    AssistContext, AssistId, AssistKind, Assists,
 };
-use insert_use::ImportScope;
 // Assist: extract_struct_from_enum_variant
 //
@@ -111,7 +112,8 @@ fn insert_import(
        let scope = ImportScope::find_insert_use_container(path.syntax(), ctx)?;
        let syntax = scope.as_syntax_node();
-        let new_syntax = insert_use(&scope, mod_path.to_ast_path(), ctx.config.insert_use.merge);
+        let new_syntax =
+            insert_use(&scope, mod_path_to_ast(&mod_path), ctx.config.insert_use.merge);
        // FIXME: this will currently panic as multiple imports will have overlapping text ranges
        builder.replace(syntax.text_range(), new_syntax.to_string())
    }
diff --git a/crates/assists/src/handlers/fill_match_arms.rs b/crates/assists/src/handlers/fill_match_arms.rs
index 3d9bdb2bf..676f5ad92 100644
--- a/crates/assists/src/handlers/fill_match_arms.rs
+++ b/crates/assists/src/handlers/fill_match_arms.rs
@@ -7,7 +7,7 @@ use syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
 use test_utils::mark;
 use crate::{
-    utils::{render_snippet, Cursor, FamousDefs},
+    utils::{mod_path_to_ast, render_snippet, Cursor, FamousDefs},
    AssistContext, AssistId, AssistKind, Assists,
 };
@@ -192,7 +192,7 @@ fn resolve_tuple_of_enum_def(
 }
 fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> Option<ast::Pat> {
-    let path = crate::ast_transform::path_to_ast(module.find_use_path(db, ModuleDef::from(var))?);
+    let path = mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var))?);
    // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
    let pat: ast::Pat = match var.source(db).value.kind() {
diff --git a/crates/assists/src/handlers/remove_dbg.rs b/crates/assists/src/handlers/remove_dbg.rs
index a8ab2aecc..e10616779 100644
--- a/crates/assists/src/handlers/remove_dbg.rs
+++ b/crates/assists/src/handlers/remove_dbg.rs
@@ -1,6 +1,6 @@
 use syntax::{
    ast::{self, AstNode},
-    SyntaxElement, TextRange, TextSize, T,
+    SyntaxElement, SyntaxKind, TextRange, TextSize, T,
 };
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -117,7 +117,10 @@ fn needs_parentheses_around_macro_contents(macro_contents: Vec<SyntaxElement>) -
            }
            symbol_kind => {
                let symbol_not_in_bracket = unpaired_brackets_in_contents.is_empty();
-                if symbol_not_in_bracket && symbol_kind.is_punct() {
+                if symbol_not_in_bracket
+                    && symbol_kind != SyntaxKind::COLON
+                    && symbol_kind.is_punct()
+                {
                    return true;
                }
            }
@@ -159,6 +162,8 @@ fn foo(n: usize) {
 }
 ",
        );
+        check_assist(remove_dbg, "<|>dbg!(Foo::foo_test()).bar()", "Foo::foo_test().bar()");
    }
    #[test]
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index cbac53e71..a2bec818c 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -128,6 +128,7 @@ mod handlers {
    mod auto_import;
    mod change_return_type_to_result;
    mod change_visibility;
+    mod convert_integer_literal;
    mod early_return;
    mod expand_glob_import;
    mod extract_struct_from_enum_variant;
@@ -172,6 +173,7 @@ mod handlers {
            auto_import::auto_import,
            change_return_type_to_result::change_return_type_to_result,
            change_visibility::change_visibility,
+            convert_integer_literal::convert_integer_literal,
            early_return::convert_to_guarded_return,
            expand_glob_import::expand_glob_import,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
diff --git a/crates/assists/src/tests.rs b/crates/assists/src/tests.rs
index ba1fb543b..2b687decf 100644
--- a/crates/assists/src/tests.rs
+++ b/crates/assists/src/tests.rs
@@ -15,18 +15,30 @@ pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
 pub(crate) fn check_assist(assist: Handler, ra_fixture_before: &str, ra_fixture_after: &str) {
    let ra_fixture_after = trim_indent(ra_fixture_after);
-    check(assist, ra_fixture_before, ExpectedResult::After(&ra_fixture_after));
+    check(assist, ra_fixture_before, ExpectedResult::After(&ra_fixture_after), None);
+}
+// There is no way to choose what assist within a group you want to test against,
+// so this is here to allow you choose.
+pub(crate) fn check_assist_by_label(
+    assist: Handler,
+    ra_fixture_before: &str,
+    ra_fixture_after: &str,
+    label: &str,
+) {
+    let ra_fixture_after = trim_indent(ra_fixture_after);
+    check(assist, ra_fixture_before, ExpectedResult::After(&ra_fixture_after), Some(label));
 }
 // FIXME: instead of having a separate function here, maybe use
 // `extract_ranges` and mark the target as `<target> </target>` in the
 // fixture?
 pub(crate) fn check_assist_target(assist: Handler, ra_fixture: &str, target: &str) {
-    check(assist, ra_fixture, ExpectedResult::Target(target));
+    check(assist, ra_fixture, ExpectedResult::Target(target), None);
 }
 pub(crate) fn check_assist_not_applicable(assist: Handler, ra_fixture: &str) {
-    check(assist, ra_fixture, ExpectedResult::NotApplicable);
+    check(assist, ra_fixture, ExpectedResult::NotApplicable, None);
 }
 fn check_doc_test(assist_id: &str, before: &str, after: &str) {
@@ -65,7 +77,7 @@ enum ExpectedResult<'a> {
    Target(&'a str),
 }
-fn check(handler: Handler, before: &str, expected: ExpectedResult) {
+fn check(handler: Handler, before: &str, expected: ExpectedResult, assist_label: Option<&str>) {
    let (db, file_with_caret_id, range_or_offset) = RootDatabase::with_range_or_offset(before);
    let text_without_caret = db.file_text(file_with_caret_id).to_string();
@@ -77,7 +89,12 @@ fn check(handler: Handler, before: &str, expected: ExpectedResult) {
    let mut acc = Assists::new_resolved(&ctx);
    handler(&mut acc, &ctx);
    let mut res = acc.finish_resolved();
-    let assist = res.pop();
+    let assist = match assist_label {
+        Some(label) => res.into_iter().find(|resolved| resolved.assist.label == label),
+        None => res.pop(),
+    };
    match (assist, expected) {
        (Some(assist), ExpectedResult::After(after)) => {
            let mut source_change = assist.source_change;
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index 27d15adb0..7f6e98a54 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -204,6 +204,19 @@ pub(crate) fn frobnicate() {}
 }
 #[test]
+fn doctest_convert_integer_literal() {
+    check_doc_test(
+        "convert_integer_literal",
+        r#####"
+const _: i32 = 10<|>;
+"#####,
+        r#####"
+const _: i32 = 0b1010;
+"#####,
+    )
+}
+#[test]
 fn doctest_convert_to_guarded_return() {
    check_doc_test(
        "convert_to_guarded_return",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index b0511ceb6..c1847f601 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -3,7 +3,7 @@ pub(crate) mod insert_use;
 use std::{iter, ops};
-use hir::{Adt, Crate, Enum, ScopeDef, Semantics, Trait, Type};
+use hir::{Adt, Crate, Enum, Module, ScopeDef, Semantics, Trait, Type};
 use ide_db::RootDatabase;
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
@@ -19,6 +19,27 @@ use crate::assist_config::SnippetCap;
 pub use insert_use::MergeBehaviour;
 pub(crate) use insert_use::{insert_use, ImportScope};
+pub fn mod_path_to_ast(path: &hir::ModPath) -> ast::Path {
+    let mut segments = Vec::new();
+    let mut is_abs = false;
+    match path.kind {
+        hir::PathKind::Plain => {}
+        hir::PathKind::Super(0) => segments.push(make::path_segment_self()),
+        hir::PathKind::Super(n) => segments.extend((0..n).map(|_| make::path_segment_super())),
+        hir::PathKind::DollarCrate(_) | hir::PathKind::Crate => {
+            segments.push(make::path_segment_crate())
+        }
+        hir::PathKind::Abs => is_abs = true,
+    }
+    segments.extend(
+        path.segments
+            .iter()
+            .map(|segment| make::path_segment(make::name_ref(&segment.to_string()))),
+    );
+    make::path_from_segments(segments, is_abs)
+}
 pub(crate) fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr {
    extract_trivial_expression(&block)
        .filter(|expr| !expr.syntax().text().contains_char('\n'))
@@ -253,15 +274,79 @@ impl TryEnum {
 /// somewhat similar to the known paths infra inside hir, but it different; We
 /// want to make sure that IDE specific paths don't become interesting inside
 /// the compiler itself as well.
-pub(crate) struct FamousDefs<'a, 'b>(pub(crate) &'a Semantics<'b, RootDatabase>, pub(crate) Crate);
+pub struct FamousDefs<'a, 'b>(pub &'a Semantics<'b, RootDatabase>, pub Crate);
 #[allow(non_snake_case)]
 impl FamousDefs<'_, '_> {
-    #[cfg(test)]
+    pub const FIXTURE: &'static str = r#"//- /libcore.rs crate:core
-    pub(crate) const FIXTURE: &'static str = r#"//- /libcore.rs crate:core
 pub mod convert {
    pub trait From<T> {
-        fn from(T) -> Self;
+        fn from(t: T) -> Self;
+    }
+}
+pub mod iter {
+    pub use self::traits::{collect::IntoIterator, iterator::Iterator};
+    mod traits {
+        pub(crate) mod iterator {
+            use crate::option::Option;
+            pub trait Iterator {
+                type Item;
+                fn next(&mut self) -> Option<Self::Item>;
+                fn by_ref(&mut self) -> &mut Self {
+                    self
+                }
+                fn take(self, n: usize) -> crate::iter::Take<Self> {
+                    crate::iter::Take { inner: self }
+                }
+            }
+            impl<I: Iterator> Iterator for &mut I {
+                type Item = I::Item;
+                fn next(&mut self) -> Option<I::Item> {
+                    (**self).next()
+                }
+            }
+        }
+        pub(crate) mod collect {
+            pub trait IntoIterator {
+                type Item;
+            }
+        }
+    }
+    pub use self::sources::*;
+    pub(crate) mod sources {
+        use super::Iterator;
+        use crate::option::Option::{self, *};
+        pub struct Repeat<A> {
+            element: A,
+        }
+        pub fn repeat<T>(elt: T) -> Repeat<T> {
+            Repeat { element: elt }
+        }
+        impl<A> Iterator for Repeat<A> {
+            type Item = A;
+            fn next(&mut self) -> Option<A> {
+                None
+            }
+        }
+    }
+    pub use self::adapters::*;
+    pub(crate) mod adapters {
+        use super::Iterator;
+        use crate::option::Option::{self, *};
+        pub struct Take<I> { pub(crate) inner: I }
+        impl<I> Iterator for Take<I> where I: Iterator {
+            type Item = <I as Iterator>::Item;
+            fn next(&mut self) -> Option<<I as Iterator>::Item> {
+                None
+            }
+        }
    }
 }
@@ -270,7 +355,7 @@ pub mod option {
 }
 pub mod prelude {
-    pub use crate::{convert::From, option::Option::{self, *}};
+    pub use crate::{convert::From, iter::{IntoIterator, Iterator}, option::Option::{self, *}};
 }
 #[prelude_import]
 pub use prelude::*;
@@ -284,6 +369,14 @@ pub use prelude::*;
        self.find_enum("core:option:Option")
    }
+    pub fn core_iter_Iterator(&self) -> Option<Trait> {
+        self.find_trait("core:iter:traits:iterator:Iterator")
+    }
+    pub fn core_iter(&self) -> Option<Module> {
+        self.find_module("core:iter")
+    }
    fn find_trait(&self, path: &str) -> Option<Trait> {
        match self.find_def(path)? {
            hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it),
@@ -298,23 +391,33 @@ pub use prelude::*;
        }
    }
+    fn find_module(&self, path: &str) -> Option<Module> {
+        match self.find_def(path)? {
+            hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(it)) => Some(it),
+            _ => None,
+        }
+    }
    fn find_def(&self, path: &str) -> Option<ScopeDef> {
        let db = self.0.db;
        let mut path = path.split(':');
        let trait_ = path.next_back()?;
        let std_crate = path.next()?;
-        let std_crate = self
+        let std_crate = if self
            .1
-            .dependencies(db)
+            .declaration_name(db)
-            .into_iter()
+            .map(|name| name.to_string() == std_crate)
-            .find(|dep| &dep.name.to_string() == std_crate)?
+            .unwrap_or(false)
-            .krate;
+        {
+            self.1
+        } else {
+            self.1.dependencies(db).into_iter().find(|dep| dep.name.to_string() == std_crate)?.krate
+        };
        let mut module = std_crate.root_module(db);
        for segment in path {
            module = module.children(db).find_map(|child| {
                let name = child.name(db)?;
-                if &name.to_string() == segment {
+                if name.to_string() == segment {
                    Some(child)
                } else {
                    None
@@ -322,7 +425,7 @@ pub use prelude::*;
            })?;
        }
        let def =
-            module.scope(db, None).into_iter().find(|(name, _def)| &name.to_string() == trait_)?.1;
+            module.scope(db, None).into_iter().find(|(name, _def)| name.to_string() == trait_)?.1;
        Some(def)
    }
 }
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index b7286fc7d..72f1fd667 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -154,19 +154,19 @@ impl ChangeFixture {
            assert!(meta.path.starts_with(&source_root_prefix));
            if let Some(krate) = meta.krate {
+                let crate_name = CrateName::normalize_dashes(&krate);
                let crate_id = crate_graph.add_crate_root(
                    file_id,
                    meta.edition,
-                    Some(krate.clone()),
+                    Some(crate_name.clone()),
                    meta.cfg,
                    meta.env,
                    Default::default(),
                );
-                let crate_name = CrateName::new(&krate).unwrap();
                let prev = crates.insert(crate_name.clone(), crate_id);
                assert!(prev.is_none());
                for dep in meta.deps {
-                    let dep = CrateName::new(&dep).unwrap();
+                    let dep = CrateName::normalize_dashes(&dep);
                    crate_deps.push((crate_name.clone(), dep))
                }
            } else if meta.path == "/main.rs" || meta.path == "/lib.rs" {
@@ -187,7 +187,7 @@ impl ChangeFixture {
            crate_graph.add_crate_root(
                crate_root,
                Edition::Edition2018,
-                Some("test".to_string()),
+                Some(CrateName::new("test").unwrap()),
                default_cfg,
                Env::default(),
                Default::default(),
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 9a61f1d56..c330314d4 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -127,10 +127,11 @@ impl PartialEq for ProcMacro {
 pub struct CrateData {
    pub root_file_id: FileId,
    pub edition: Edition,
-    /// The name to display to the end user.
+    /// A name used in the package's project declaration: for Cargo projects, it's [package].name,
-    /// This actual crate name can be different in a particular dependent crate
+    /// can be different for other project types or even absent (a dummy crate for the code snippet, for example).
-    /// or may even be missing for some cases, such as a dummy crate for the code snippet.
+    /// NOTE: The crate can be referenced as a dependency under a different name,
-    pub display_name: Option<String>,
+    /// this one should be used when working with crate hierarchies.
+    pub declaration_name: Option<CrateName>,
    pub cfg_options: CfgOptions,
    pub env: Env,
    pub dependencies: Vec<Dependency>,
@@ -159,7 +160,7 @@ impl CrateGraph {
        &mut self,
        file_id: FileId,
        edition: Edition,
-        display_name: Option<String>,
+        declaration_name: Option<CrateName>,
        cfg_options: CfgOptions,
        env: Env,
        proc_macro: Vec<(SmolStr, Arc<dyn tt::TokenExpander>)>,
@@ -170,7 +171,7 @@ impl CrateGraph {
        let data = CrateData {
            root_file_id: file_id,
            edition,
-            display_name,
+            declaration_name,
            cfg_options,
            env,
            proc_macro,
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 5721a66c4..031c91ccf 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -2,8 +2,9 @@
 use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
-use base_db::{CrateId, Edition, FileId};
+use base_db::{CrateId, CrateName, Edition, FileId};
 use either::Either;
+use hir_def::find_path::PrefixKind;
 use hir_def::{
    adt::ReprKind,
    adt::StructKind,
@@ -29,8 +30,12 @@ use hir_expand::{
 use hir_ty::{
    autoderef,
    display::{HirDisplayError, HirFormatter},
-    method_resolution, ApplicationTy, CallableDefId, Canonical, FnSig, GenericPredicate,
+    method_resolution,
-    InEnvironment, Substs, TraitEnvironment, Ty, TyDefId, TypeCtor,
+    traits::Solution,
+    traits::SolutionVariables,
+    ApplicationTy, BoundVar, CallableDefId, Canonical, DebruijnIndex, FnSig, GenericPredicate,
+    InEnvironment, Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, Ty,
+    TyDefId, TyKind, TypeCtor,
 };
 use rustc_hash::FxHashSet;
 use stdx::impl_from;
@@ -98,8 +103,8 @@ impl Crate {
        db.crate_graph()[self.id].edition
    }
-    pub fn display_name(self, db: &dyn HirDatabase) -> Option<String> {
+    pub fn declaration_name(self, db: &dyn HirDatabase) -> Option<CrateName> {
-        db.crate_graph()[self.id].display_name.clone()
+        db.crate_graph()[self.id].declaration_name.clone()
    }
    pub fn query_external_importables(
@@ -390,8 +395,9 @@ impl Module {
        self,
        db: &dyn DefDatabase,
        item: impl Into<ItemInNs>,
+        prefix_kind: PrefixKind,
    ) -> Option<ModPath> {
-        hir_def::find_path::find_path_prefixed(db, item.into(), self.into())
+        hir_def::find_path::find_path_prefixed(db, item.into(), self.into(), prefix_kind)
    }
 }
@@ -1360,6 +1366,35 @@ impl Type {
        db.trait_solve(self.krate, goal).is_some()
    }
+    pub fn normalize_trait_assoc_type(
+        &self,
+        db: &dyn HirDatabase,
+        r#trait: Trait,
+        args: &[Type],
+        alias: TypeAlias,
+    ) -> Option<Ty> {
+        let subst = Substs::build_for_def(db, r#trait.id)
+            .push(self.ty.value.clone())
+            .fill(args.iter().map(|t| t.ty.value.clone()))
+            .build();
+        let predicate = ProjectionPredicate {
+            projection_ty: ProjectionTy { associated_ty: alias.id, parameters: subst },
+            ty: Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0)),
+        };
+        let goal = Canonical {
+            value: InEnvironment::new(
+                self.ty.environment.clone(),
+                Obligation::Projection(predicate),
+            ),
+            kinds: Arc::new([TyKind::General]),
+        };
+        match db.trait_solve(self.krate, goal)? {
+            Solution::Unique(SolutionVariables(subst)) => subst.value.first().cloned(),
+            Solution::Ambig(_) => None,
+        }
+    }
    pub fn is_copy(&self, db: &dyn HirDatabase) -> bool {
        let lang_item = db.lang_item(self.krate, SmolStr::new("copy"));
        let copy_trait = match lang_item {
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index b9d9c7e25..4094a76cb 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -48,13 +48,14 @@ pub use hir_def::{
    body::scope::ExprScopes,
    builtin_type::BuiltinType,
    docs::Documentation,
+    find_path::PrefixKind,
    item_scope::ItemInNs,
    nameres::ModuleSource,
-    path::ModPath,
+    path::{ModPath, PathKind},
    type_ref::{Mutability, TypeRef},
 };
 pub use hir_expand::{
-    name::AsName, name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc,
+    name::known, name::AsName, name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc,
    /* FIXME */ MacroDefId, MacroFile, Origin,
 };
 pub use hir_ty::display::HirDisplay;
@@ -62,7 +63,4 @@ pub use hir_ty::display::HirDisplay;
 // These are negative re-exports: pub using these names is forbidden, they
 // should remain private to hir internals.
 #[allow(unused)]
-use {
+use {hir_def::path::Path, hir_expand::hygiene::Hygiene};
-    hir_def::path::{Path, PathKind},
-    hir_expand::hygiene::Hygiene,
-};
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index baf374144..02613c4c4 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -19,12 +19,17 @@ use crate::{
 /// *from where* you're referring to the item, hence the `from` parameter.
 pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
    let _p = profile::span("find_path");
-    find_path_inner(db, item, from, MAX_PATH_LEN, Prefixed::Not)
+    find_path_inner(db, item, from, MAX_PATH_LEN, None)
 }
-pub fn find_path_prefixed(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
+pub fn find_path_prefixed(
-    let _p = profile::span("find_path_absolute");
+    db: &dyn DefDatabase,
-    find_path_inner(db, item, from, MAX_PATH_LEN, Prefixed::Plain)
+    item: ItemInNs,
+    from: ModuleId,
+    prefix_kind: PrefixKind,
+) -> Option<ModPath> {
+    let _p = profile::span("find_path_prefixed");
+    find_path_inner(db, item, from, MAX_PATH_LEN, Some(prefix_kind))
 }
 const MAX_PATH_LEN: usize = 15;
@@ -42,58 +47,52 @@ impl ModPath {
    }
 }
-fn check_crate_self_super(
+fn check_self_super(def_map: &CrateDefMap, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
-    def_map: &CrateDefMap,
+    if item == ItemInNs::Types(from.into()) {
-    item: ItemInNs,
-    from: ModuleId,
-) -> Option<ModPath> {
-    // - if the item is the crate root, return `crate`
-    if item
-        == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
-            krate: from.krate,
-            local_id: def_map.root,
-        }))
-    {
-        Some(ModPath::from_segments(PathKind::Crate, Vec::new()))
-    } else if item == ItemInNs::Types(from.into()) {
        // - if the item is the module we're in, use `self`
        Some(ModPath::from_segments(PathKind::Super(0), Vec::new()))
-    } else {
+    } else if let Some(parent_id) = def_map.modules[from.local_id].parent {
-        if let Some(parent_id) = def_map.modules[from.local_id].parent {
+        // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
-            // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
+        if item
-            if item
+            == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
-                == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
+                krate: from.krate,
-                    krate: from.krate,
+                local_id: parent_id,
-                    local_id: parent_id,
+            }))
-                }))
+        {
-            {
+            Some(ModPath::from_segments(PathKind::Super(1), Vec::new()))
-                return Some(ModPath::from_segments(PathKind::Super(1), Vec::new()));
+        } else {
-            }
+            None
        }
+    } else {
        None
    }
 }
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum Prefixed {
+pub enum PrefixKind {
-    Not,
+    /// Causes paths to always start with either `self`, `super`, `crate` or a crate-name.
+    /// This is the same as plain, just that paths will start with `self` iprepended f the path
+    /// starts with an identifier that is not a crate.
    BySelf,
+    /// Causes paths to ignore imports in the local module.
    Plain,
+    /// Causes paths to start with `crate` where applicable, effectively forcing paths to be absolute.
+    ByCrate,
 }
-impl Prefixed {
+impl PrefixKind {
    #[inline]
-    fn prefix(self) -> Option<PathKind> {
+    fn prefix(self) -> PathKind {
        match self {
-            Prefixed::Not => None,
+            PrefixKind::BySelf => PathKind::Super(0),
-            Prefixed::BySelf => Some(PathKind::Super(0)),
+            PrefixKind::Plain => PathKind::Plain,
-            Prefixed::Plain => Some(PathKind::Plain),
+            PrefixKind::ByCrate => PathKind::Crate,
        }
    }
    #[inline]
-    fn prefixed(self) -> bool {
+    fn is_absolute(&self) -> bool {
-        self != Prefixed::Not
+        self == &PrefixKind::ByCrate
    }
 }
@@ -102,7 +101,7 @@ fn find_path_inner(
    item: ItemInNs,
    from: ModuleId,
    max_len: usize,
-    prefixed: Prefixed,
+    prefixed: Option<PrefixKind>,
 ) -> Option<ModPath> {
    if max_len == 0 {
        return None;
@@ -115,13 +114,25 @@ fn find_path_inner(
    let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope;
    let scope_name =
        if let Some((name, _)) = from_scope.name_of(item) { Some(name.clone()) } else { None };
-    if !prefixed.prefixed() && scope_name.is_some() {
+    if prefixed.is_none() && scope_name.is_some() {
        return scope_name
            .map(|scope_name| ModPath::from_segments(PathKind::Plain, vec![scope_name]));
    }
-    if let modpath @ Some(_) = check_crate_self_super(&def_map, item, from) {
+    // - if the item is the crate root, return `crate`
-        return modpath;
+    if item
+        == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
+            krate: from.krate,
+            local_id: def_map.root,
+        }))
+    {
+        return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
+    }
+    if prefixed.filter(PrefixKind::is_absolute).is_none() {
+        if let modpath @ Some(_) = check_self_super(&def_map, item, from) {
+            return modpath;
+        }
    }
    // - if the item is the crate root of a dependency crate, return the name from the extern prelude
@@ -211,6 +222,7 @@ fn find_path_inner(
                    best_path_len - 1,
                    prefixed,
                )?;
+                mark::hit!(partially_imported);
                path.segments.push(info.path.segments.last().unwrap().clone());
                Some(path)
            })
@@ -226,7 +238,7 @@ fn find_path_inner(
        }
    }
-    if let Some(prefix) = prefixed.prefix() {
+    if let Some(prefix) = prefixed.map(PrefixKind::prefix) {
        best_path.or_else(|| {
            scope_name.map(|scope_name| ModPath::from_segments(prefix, vec![scope_name]))
        })
@@ -355,7 +367,7 @@ mod tests {
    /// `code` needs to contain a cursor marker; checks that `find_path` for the
    /// item the `path` refers to returns that same path when called from the
    /// module the cursor is in.
-    fn check_found_path_(ra_fixture: &str, path: &str, absolute: bool) {
+    fn check_found_path_(ra_fixture: &str, path: &str, prefix_kind: Option<PrefixKind>) {
        let (db, pos) = TestDB::with_position(ra_fixture);
        let module = db.module_for_file(pos.file_id);
        let parsed_path_file = syntax::SourceFile::parse(&format!("use {};", path));
@@ -375,20 +387,22 @@ mod tests {
            .take_types()
            .unwrap();
-        let found_path = if absolute { find_path_prefixed } else { find_path }(
+        let found_path =
-            &db,
+            find_path_inner(&db, ItemInNs::Types(resolved), module, MAX_PATH_LEN, prefix_kind);
-            ItemInNs::Types(resolved),
+        assert_eq!(found_path, Some(mod_path), "{:?}", prefix_kind);
-            module,
-        );
-        assert_eq!(found_path, Some(mod_path), "absolute {}", absolute);
    }
-    fn check_found_path(ra_fixture: &str, path: &str) {
+    fn check_found_path(
-        check_found_path_(ra_fixture, path, false);
+        ra_fixture: &str,
-    }
+        unprefixed: &str,
+        prefixed: &str,
-    fn check_found_path_abs(ra_fixture: &str, path: &str) {
+        absolute: &str,
-        check_found_path_(ra_fixture, path, true);
+        self_prefixed: &str,
+    ) {
+        check_found_path_(ra_fixture, unprefixed, None);
+        check_found_path_(ra_fixture, prefixed, Some(PrefixKind::Plain));
+        check_found_path_(ra_fixture, absolute, Some(PrefixKind::ByCrate));
+        check_found_path_(ra_fixture, self_prefixed, Some(PrefixKind::BySelf));
    }
    #[test]
@@ -398,8 +412,7 @@ mod tests {
            struct S;
            <|>
        "#;
-        check_found_path(code, "S");
+        check_found_path(code, "S", "S", "crate::S", "self::S");
-        check_found_path_abs(code, "S");
    }
    #[test]
@@ -409,8 +422,7 @@ mod tests {
            enum E { A }
            <|>
        "#;
-        check_found_path(code, "E::A");
+        check_found_path(code, "E::A", "E::A", "E::A", "E::A");
-        check_found_path_abs(code, "E::A");
    }
    #[test]
@@ -422,8 +434,7 @@ mod tests {
            }
            <|>
        "#;
-        check_found_path(code, "foo::S");
+        check_found_path(code, "foo::S", "foo::S", "crate::foo::S", "self::foo::S");
-        check_found_path_abs(code, "foo::S");
    }
    #[test]
@@ -437,8 +448,7 @@ mod tests {
            //- /foo/bar.rs
            <|>
        "#;
-        check_found_path(code, "super::S");
+        check_found_path(code, "super::S", "super::S", "crate::foo::S", "super::S");
-        check_found_path_abs(code, "super::S");
    }
    #[test]
@@ -449,8 +459,7 @@ mod tests {
            //- /foo.rs
            <|>
        "#;
-        check_found_path(code, "self");
+        check_found_path(code, "self", "self", "crate::foo", "self");
-        check_found_path_abs(code, "self");
    }
    #[test]
@@ -461,8 +470,7 @@ mod tests {
            //- /foo.rs
            <|>
        "#;
-        check_found_path(code, "crate");
+        check_found_path(code, "crate", "crate", "crate", "crate");
-        check_found_path_abs(code, "crate");
    }
    #[test]
@@ -474,8 +482,7 @@ mod tests {
            //- /foo.rs
            <|>
        "#;
-        check_found_path(code, "crate::S");
+        check_found_path(code, "crate::S", "crate::S", "crate::S", "crate::S");
-        check_found_path_abs(code, "crate::S");
    }
    #[test]
@@ -486,8 +493,7 @@ mod tests {
            //- /std.rs crate:std
            pub struct S;
        "#;
-        check_found_path(code, "std::S");
+        check_found_path(code, "std::S", "std::S", "std::S", "std::S");
-        check_found_path_abs(code, "std::S");
    }
    #[test]
@@ -499,12 +505,18 @@ mod tests {
            //- /std.rs crate:std
            pub struct S;
        "#;
-        check_found_path(code, "std_renamed::S");
+        check_found_path(
-        check_found_path_abs(code, "std_renamed::S");
+            code,
+            "std_renamed::S",
+            "std_renamed::S",
+            "std_renamed::S",
+            "std_renamed::S",
+        );
    }
    #[test]
    fn partially_imported() {
+        mark::check!(partially_imported);
        // Tests that short paths are used even for external items, when parts of the path are
        // already in scope.
        let code = r#"
@@ -520,8 +532,13 @@ mod tests {
                }
            }
        "#;
-        check_found_path(code, "ast::ModuleItem");
+        check_found_path(
-        check_found_path_abs(code, "syntax::ast::ModuleItem");
+            code,
+            "ast::ModuleItem",
+            "syntax::ast::ModuleItem",
+            "syntax::ast::ModuleItem",
+            "syntax::ast::ModuleItem",
+        );
        let code = r#"
            //- /main.rs crate:main deps:syntax
@@ -535,8 +552,13 @@ mod tests {
                }
            }
        "#;
-        check_found_path(code, "syntax::ast::ModuleItem");
+        check_found_path(
-        check_found_path_abs(code, "syntax::ast::ModuleItem");
+            code,
+            "syntax::ast::ModuleItem",
+            "syntax::ast::ModuleItem",
+            "syntax::ast::ModuleItem",
+            "syntax::ast::ModuleItem",
+        );
    }
    #[test]
@@ -549,8 +571,7 @@ mod tests {
            }
            <|>
        "#;
-        check_found_path(code, "bar::S");
+        check_found_path(code, "bar::S", "bar::S", "crate::bar::S", "self::bar::S");
-        check_found_path_abs(code, "bar::S");
    }
    #[test]
@@ -563,8 +584,7 @@ mod tests {
            }
            <|>
        "#;
-        check_found_path(code, "bar::U");
+        check_found_path(code, "bar::U", "bar::U", "crate::bar::U", "self::bar::U");
-        check_found_path_abs(code, "bar::U");
    }
    #[test]
@@ -577,8 +597,7 @@ mod tests {
            //- /core.rs crate:core
            pub struct S;
        "#;
-        check_found_path(code, "std::S");
+        check_found_path(code, "std::S", "std::S", "std::S", "std::S");
-        check_found_path_abs(code, "std::S");
    }
    #[test]
@@ -591,8 +610,7 @@ mod tests {
            #[prelude_import]
            pub use prelude::*;
        "#;
-        check_found_path(code, "S");
+        check_found_path(code, "S", "S", "S", "S");
-        check_found_path_abs(code, "S");
    }
    #[test]
@@ -608,10 +626,8 @@ mod tests {
            #[prelude_import]
            pub use prelude::*;
        "#;
-        check_found_path(code, "None");
+        check_found_path(code, "None", "None", "None", "None");
-        check_found_path(code, "Some");
+        check_found_path(code, "Some", "Some", "Some", "Some");
-        check_found_path_abs(code, "None");
-        check_found_path_abs(code, "Some");
    }
    #[test]
@@ -627,8 +643,7 @@ mod tests {
            //- /baz.rs
            pub use crate::foo::bar::S;
        "#;
-        check_found_path(code, "baz::S");
+        check_found_path(code, "baz::S", "baz::S", "crate::baz::S", "self::baz::S");
-        check_found_path_abs(code, "baz::S");
    }
    #[test]
@@ -642,8 +657,7 @@ mod tests {
            <|>
        "#;
        // crate::S would be shorter, but using private imports seems wrong
-        check_found_path(code, "crate::bar::S");
+        check_found_path(code, "crate::bar::S", "crate::bar::S", "crate::bar::S", "crate::bar::S");
-        check_found_path_abs(code, "crate::bar::S");
    }
    #[test]
@@ -661,8 +675,7 @@ mod tests {
            //- /baz.rs
            pub use super::foo;
        "#;
-        check_found_path(code, "crate::foo::S");
+        check_found_path(code, "crate::foo::S", "crate::foo::S", "crate::foo::S", "crate::foo::S");
-        check_found_path_abs(code, "crate::foo::S");
    }
    #[test]
@@ -682,8 +695,13 @@ mod tests {
            pub struct Arc;
        }
        "#;
-        check_found_path(code, "std::sync::Arc");
+        check_found_path(
-        check_found_path_abs(code, "std::sync::Arc");
+            code,
+            "std::sync::Arc",
+            "std::sync::Arc",
+            "std::sync::Arc",
+            "std::sync::Arc",
+        );
    }
    #[test]
@@ -707,8 +725,13 @@ mod tests {
            pub struct Error;
        }
        "#;
-        check_found_path(code, "core::fmt::Error");
+        check_found_path(
-        check_found_path_abs(code, "core::fmt::Error");
+            code,
+            "core::fmt::Error",
+            "core::fmt::Error",
+            "core::fmt::Error",
+            "core::fmt::Error",
+        );
    }
    #[test]
@@ -731,8 +754,13 @@ mod tests {
            pub struct Arc;
        }
        "#;
-        check_found_path(code, "alloc::sync::Arc");
+        check_found_path(
-        check_found_path_abs(code, "alloc::sync::Arc");
+            code,
+            "alloc::sync::Arc",
+            "alloc::sync::Arc",
+            "alloc::sync::Arc",
+            "alloc::sync::Arc",
+        );
    }
    #[test]
@@ -749,8 +777,13 @@ mod tests {
        //- /zzz.rs crate:megaalloc
        pub struct Arc;
        "#;
-        check_found_path(code, "megaalloc::Arc");
+        check_found_path(
-        check_found_path_abs(code, "megaalloc::Arc");
+            code,
+            "megaalloc::Arc",
+            "megaalloc::Arc",
+            "megaalloc::Arc",
+            "megaalloc::Arc",
+        );
    }
    #[test]
@@ -763,9 +796,7 @@ mod tests {
            pub use u8;
        }
        "#;
-        check_found_path(code, "u8");
+        check_found_path(code, "u8", "u8", "u8", "u8");
-        check_found_path(code, "u16");
+        check_found_path(code, "u16", "u16", "u16", "u16");
-        check_found_path_abs(code, "u8");
-        check_found_path_abs(code, "u16");
    }
 }
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index a442fb63a..028cae2e7 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -4,17 +4,16 @@ use std::{cmp::Ordering, fmt, hash::BuildHasherDefault, sync::Arc};
 use base_db::CrateId;
 use fst::{self, Streamer};
+use hir_expand::name::Name;
 use indexmap::{map::Entry, IndexMap};
+use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHasher};
 use smallvec::SmallVec;
 use syntax::SmolStr;
 use crate::{
-    db::DefDatabase,
+    db::DefDatabase, item_scope::ItemInNs, visibility::Visibility, AssocItemId, ModuleDefId,
-    item_scope::ItemInNs,
+    ModuleId, TraitId,
-    path::{ModPath, PathKind},
-    visibility::Visibility,
-    AssocItemId, ModuleDefId, ModuleId, TraitId,
 };
 type FxIndexMap<K, V> = IndexMap<K, V, BuildHasherDefault<FxHasher>>;
@@ -23,11 +22,28 @@ type FxIndexMap<K, V> = IndexMap<K, V, BuildHasherDefault<FxHasher>>;
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ImportInfo {
    /// A path that can be used to import the item, relative to the crate's root.
-    pub path: ModPath,
+    pub path: ImportPath,
    /// The module containing this item.
    pub container: ModuleId,
 }
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ImportPath {
+    pub segments: Vec<Name>,
+}
+impl fmt::Display for ImportPath {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.segments.iter().format("::"), f)
+    }
+}
+impl ImportPath {
+    fn len(&self) -> usize {
+        self.segments.len()
+    }
+}
 /// A map from publicly exported items to the path needed to import/name them from a downstream
 /// crate.
 ///
@@ -61,7 +77,7 @@ impl ImportMap {
        let mut import_map = Self::default();
        // We look only into modules that are public(ly reexported), starting with the crate root.
-        let empty = ModPath { kind: PathKind::Plain, segments: vec![] };
+        let empty = ImportPath { segments: vec![] };
        let root = ModuleId { krate, local_id: def_map.root };
        let mut worklist = vec![(root, empty)];
        while let Some((module, mod_path)) = worklist.pop() {
@@ -152,8 +168,8 @@ impl ImportMap {
    }
    /// Returns the `ModPath` needed to import/mention `item`, relative to this crate's root.
-    pub fn path_of(&self, item: ItemInNs) -> Option<&ModPath> {
+    pub fn path_of(&self, item: ItemInNs) -> Option<&ImportPath> {
-        Some(&self.map.get(&item)?.path)
+        self.import_info_for(item).map(|it| &it.path)
    }
    pub fn import_info_for(&self, item: ItemInNs) -> Option<&ImportInfo> {
@@ -197,7 +213,7 @@ impl fmt::Debug for ImportMap {
    }
 }
-fn fst_path(path: &ModPath) -> String {
+fn fst_path(path: &ImportPath) -> String {
    let mut s = path.to_string();
    s.make_ascii_lowercase();
    s
@@ -334,14 +350,14 @@ mod tests {
    use super::*;
-    fn check_search(ra_fixture: &str, krate_name: &str, query: Query, expect: Expect) {
+    fn check_search(ra_fixture: &str, crate_name: &str, query: Query, expect: Expect) {
        let db = TestDB::with_files(ra_fixture);
        let crate_graph = db.crate_graph();
        let krate = crate_graph
            .iter()
            .find(|krate| {
-                crate_graph[*krate].display_name.as_ref().map(|n| n.to_string())
+                crate_graph[*krate].declaration_name.as_ref().map(|n| n.to_string())
-                    == Some(krate_name.to_string())
+                    == Some(crate_name.to_string())
            })
            .unwrap();
@@ -359,7 +375,7 @@ mod tests {
                    let path = map.path_of(item).unwrap();
                    format!(
                        "{}::{} ({})\n",
-                        crate_graph[krate].display_name.as_ref().unwrap(),
+                        crate_graph[krate].declaration_name.as_ref().unwrap(),
                        path,
                        mark
                    )
@@ -400,7 +416,7 @@ mod tests {
            .iter()
            .filter_map(|krate| {
                let cdata = &crate_graph[krate];
-                let name = cdata.display_name.as_ref()?;
+                let name = cdata.declaration_name.as_ref()?;
                let map = db.import_map(krate);
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 5e4d73c1f..464ffef21 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -173,7 +173,7 @@ impl CrateDefMap {
    pub(crate) fn crate_def_map_query(db: &dyn DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
        let _p = profile::span("crate_def_map_query").detail(|| {
            db.crate_graph()[krate]
-                .display_name
+                .declaration_name
                .as_ref()
                .map(ToString::to_string)
                .unwrap_or_default()
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 100e25ffc..c8cd04264 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -1229,9 +1229,10 @@ impl ModCollector<'_, '_> {
        } else {
            let derive = attrs.by_key("proc_macro_derive");
            if let Some(arg) = derive.tt_values().next() {
-                if let [TokenTree::Leaf(Leaf::Ident(trait_name))] = &*arg.token_trees {
+                if let [TokenTree::Leaf(Leaf::Ident(trait_name)), ..] = &*arg.token_trees {
                    trait_name.as_name()
                } else {
+                    log::trace!("malformed `#[proc_macro_derive]`: {}", arg);
                    return;
                }
            } else {
diff --git a/crates/hir_def/src/nameres/tests/macros.rs b/crates/hir_def/src/nameres/tests/macros.rs
index 0851c3b7d..305fca0f9 100644
--- a/crates/hir_def/src/nameres/tests/macros.rs
+++ b/crates/hir_def/src/nameres/tests/macros.rs
@@ -688,13 +688,20 @@ fn resolves_proc_macros() {
        pub fn derive_macro(_item: TokenStream) -> TokenStream {
            TokenStream
        }
+        #[proc_macro_derive(AnotherTrait, attributes(helper_attr))]
+        pub fn derive_macro_2(_item: TokenStream) -> TokenStream {
+            TokenStream
+        }
        ",
        expect![[r#"
            crate
+            AnotherTrait: m
            DummyTrait: m
            TokenStream: t v
            attribute_macro: v m
            derive_macro: v
+            derive_macro_2: v
            function_like_macro: v m
        "#]],
    );
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 209b18e78..5b8c1e449 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -13,7 +13,7 @@ use hir_expand::{
    hygiene::Hygiene,
    name::{AsName, Name},
 };
-use syntax::ast::{self, make};
+use syntax::ast::{self};
 use crate::{
    type_ref::{TypeBound, TypeRef},
@@ -100,26 +100,6 @@ impl ModPath {
        }
        self.segments.first()
    }
-    pub fn to_ast_path(&self) -> ast::Path {
-        let mut segments = Vec::new();
-        let mut is_abs = false;
-        match self.kind {
-            PathKind::Plain => {}
-            PathKind::Super(0) => segments.push(make::path_segment_self()),
-            PathKind::Super(n) => segments.extend((0..n).map(|_| make::path_segment_super())),
-            PathKind::Crate => segments.push(make::path_segment_crate()),
-            PathKind::Abs => is_abs = true,
-            PathKind::DollarCrate(_) => (),
-        }
-        segments.extend(
-            self.segments
-                .iter()
-                .map(|segment| make::path_segment(make::name_ref(&segment.to_string()))),
-        );
-        make::path_from_segments(segments, is_abs)
-    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index a5750d829..63f828707 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -164,6 +164,7 @@ pub mod known {
        result,
        boxed,
        // Components of known path (type name)
+        Iterator,
        IntoIterator,
        Item,
        Try,
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index ed1c911c2..0f3c85926 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -17,9 +17,9 @@ ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.30.0" }
+chalk-solve = "0.32"
-chalk-ir = { version = "0.30.0" }
+chalk-ir = "0.32"
-chalk-recursive = { version = "0.30.0" }
+chalk-recursive = "0.32"
 stdx = { path = "../stdx", version = "0.0.0" }
 hir_def = { path = "../hir_def", version = "0.0.0" }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index f389c5a4b..d2e151f25 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -221,7 +221,16 @@ impl HirDisplay for ApplicationTy {
            }
            TypeCtor::RawPtr(m) => {
                let t = self.parameters.as_single();
-                write!(f, "*{}{}", m.as_keyword_for_ptr(), t.display(f.db))?;
+                let ty_display = t.display(f.db);
+                write!(f, "*{}", m.as_keyword_for_ptr())?;
+                if matches!(t, Ty::Dyn(predicates) if predicates.len() > 1) {
+                    write!(f, "(")?;
+                    write!(f, "{}", ty_display)?;
+                    write!(f, ")")?;
+                } else {
+                    write!(f, "{}", ty_display)?;
+                }
            }
            TypeCtor::Ref(m) => {
                let t = self.parameters.as_single();
@@ -230,7 +239,15 @@ impl HirDisplay for ApplicationTy {
                } else {
                    t.display(f.db)
                };
-                write!(f, "&{}{}", m.as_keyword_for_ref(), ty_display)?;
+                write!(f, "&{}", m.as_keyword_for_ref())?;
+                if matches!(t, Ty::Dyn(predicates) if predicates.len() > 1) {
+                    write!(f, "(")?;
+                    write!(f, "{}", ty_display)?;
+                    write!(f, ")")?;
+                } else {
+                    write!(f, "{}", ty_display)?;
+                }
            }
            TypeCtor::Never => write!(f, "!")?,
            TypeCtor::Tuple { .. } => {
@@ -636,14 +653,14 @@ impl HirDisplay for GenericPredicate {
 impl HirDisplay for Obligation {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        Ok(match self {
+        match self {
-            Obligation::Trait(tr) => write!(f, "Implements({})", tr.display(f.db))?,
+            Obligation::Trait(tr) => write!(f, "Implements({})", tr.display(f.db)),
            Obligation::Projection(proj) => write!(
                f,
                "Normalize({} => {})",
                proj.projection_ty.display(f.db),
                proj.ty.display(f.db)
-            )?,
+            ),
-        })
+        }
    }
 }
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 009b17a7f..cbe5cd7dd 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -330,6 +330,20 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn fn_def_name(&self, fn_def_id: chalk_ir::FnDefId<Interner>) -> String {
        format!("fn_{}", fn_def_id.0)
    }
+    fn generator_datum(
+        &self,
+        _: chalk_ir::GeneratorId<Interner>,
+    ) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorDatum<Interner>> {
+        // FIXME
+        unimplemented!()
+    }
+    fn generator_witness_datum(
+        &self,
+        _: chalk_ir::GeneratorId<Interner>,
+    ) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorWitnessDatum<Interner>> {
+        // FIXME
+        unimplemented!()
+    }
 }
 pub(crate) fn program_clauses_for_chalk_env_query(
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index d42f4bba9..be3301313 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -399,6 +399,8 @@ impl ToChalk for TypeCtor {
                // this should not be reached, since we don't represent TypeName::Error with TypeCtor
                unreachable!()
            }
+            TypeName::Generator(_) => unimplemented!(), // FIXME
+            TypeName::GeneratorWitness(_) => unimplemented!(), // FIXME
        }
    }
 }
diff --git a/crates/ide/src/completion/complete_postfix/format_like.rs b/crates/ide/src/completion/complete_postfix/format_like.rs
index 0287fc803..81c33bf3a 100644
--- a/crates/ide/src/completion/complete_postfix/format_like.rs
+++ b/crates/ide/src/completion/complete_postfix/format_like.rs
@@ -1,4 +1,4 @@
-// Feature: Postfix completion for `format`-like strings.
+// Feature: Format String Completion.
 //
 // `"Result {result} is {2 + 2}"` is expanded to the `"Result {} is {}", result, 2 + 2`.
 //
diff --git a/crates/ide/src/completion/complete_unqualified_path.rs b/crates/ide/src/completion/complete_unqualified_path.rs
index 2010d9a2f..8b6757195 100644
--- a/crates/ide/src/completion/complete_unqualified_path.rs
+++ b/crates/ide/src/completion/complete_unqualified_path.rs
@@ -267,6 +267,26 @@ fn quux() { <|> }
        );
    }
+    /// Regression test for issue #6091.
+    #[test]
+    fn correctly_completes_module_items_prefixed_with_underscore() {
+        check_edit(
+            "_alpha",
+            r#"
+fn main() {
+    _<|>
+}
+fn _alpha() {}
+"#,
+            r#"
+fn main() {
+    _alpha()$0
+}
+fn _alpha() {}
+"#,
+        )
+    }
    #[test]
    fn completes_extern_prelude() {
        check(
diff --git a/crates/ide/src/completion/completion_context.rs b/crates/ide/src/completion/completion_context.rs
index 101be8eb5..8dea8a4bf 100644
--- a/crates/ide/src/completion/completion_context.rs
+++ b/crates/ide/src/completion/completion_context.rs
@@ -221,10 +221,11 @@ impl<'a> CompletionContext<'a> {
        Some(ctx)
    }
-    // The range of the identifier that is being completed.
+    /// The range of the identifier that is being completed.
    pub(crate) fn source_range(&self) -> TextRange {
        // check kind of macro-expanded token, but use range of original token
-        if self.token.kind() == IDENT || self.token.kind().is_keyword() {
+        let kind = self.token.kind();
+        if kind == IDENT || kind == UNDERSCORE || kind.is_keyword() {
            mark::hit!(completes_if_prefix_is_keyword);
            self.original_token.text_range()
        } else {
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 9cf02f0a3..53265488e 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -15,6 +15,7 @@ use test_utils::mark;
 use crate::{
    display::{macro_label, ShortLabel, ToNav, TryToNav},
    link_rewrite::{remove_links, rewrite_links},
+    markdown_remove::remove_markdown,
    markup::Markup,
    runnables::runnable,
    FileId, FilePosition, NavigationTarget, RangeInfo, Runnable,
@@ -27,6 +28,7 @@ pub struct HoverConfig {
    pub debug: bool,
    pub goto_type_def: bool,
    pub links_in_hover: bool,
+    pub markdown: bool,
 }
 impl Default for HoverConfig {
@@ -37,6 +39,7 @@ impl Default for HoverConfig {
            debug: true,
            goto_type_def: true,
            links_in_hover: true,
+            markdown: true,
        }
    }
 }
@@ -48,6 +51,7 @@ impl HoverConfig {
        debug: false,
        goto_type_def: false,
        links_in_hover: true,
+        markdown: true,
    };
    pub fn any(&self) -> bool {
@@ -91,6 +95,7 @@ pub(crate) fn hover(
    db: &RootDatabase,
    position: FilePosition,
    links_in_hover: bool,
+    markdown: bool,
 ) -> Option<RangeInfo<HoverResult>> {
    let sema = Semantics::new(db);
    let file = sema.parse(position.file_id).syntax().clone();
@@ -109,7 +114,9 @@ pub(crate) fn hover(
    };
    if let Some(definition) = definition {
        if let Some(markup) = hover_for_definition(db, definition) {
-            let markup = if links_in_hover {
+            let markup = if !markdown {
+                remove_markdown(&markup.as_str())
+            } else if links_in_hover {
                rewrite_links(db, &markup.as_str(), &definition)
            } else {
                remove_links(&markup.as_str())
@@ -147,7 +154,11 @@ pub(crate) fn hover(
        }
    };
-    res.markup = Markup::fenced_block(&ty.display(db));
+    res.markup = if markdown {
+        Markup::fenced_block(&ty.display(db))
+    } else {
+        ty.display(db).to_string().into()
+    };
    let range = sema.original_range(&node).range;
    Some(RangeInfo::new(range, res))
 }
@@ -289,7 +300,7 @@ fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String>
 fn render_path(db: &RootDatabase, module: Module, item_name: Option<String>) -> String {
    let crate_name =
-        db.crate_graph()[module.krate().into()].display_name.as_ref().map(ToString::to_string);
+        db.crate_graph()[module.krate().into()].declaration_name.as_ref().map(ToString::to_string);
    let module_path = module
        .path_to_root(db)
        .into_iter()
@@ -383,12 +394,12 @@ mod tests {
    fn check_hover_no_result(ra_fixture: &str) {
        let (analysis, position) = fixture::position(ra_fixture);
-        assert!(analysis.hover(position, true).unwrap().is_none());
+        assert!(analysis.hover(position, true, true).unwrap().is_none());
    }
    fn check(ra_fixture: &str, expect: Expect) {
        let (analysis, position) = fixture::position(ra_fixture);
-        let hover = analysis.hover(position, true).unwrap().unwrap();
+        let hover = analysis.hover(position, true, true).unwrap().unwrap();
        let content = analysis.db.file_text(position.file_id);
        let hovered_element = &content[hover.range];
@@ -399,7 +410,18 @@ mod tests {
    fn check_hover_no_links(ra_fixture: &str, expect: Expect) {
        let (analysis, position) = fixture::position(ra_fixture);
-        let hover = analysis.hover(position, false).unwrap().unwrap();
+        let hover = analysis.hover(position, false, true).unwrap().unwrap();
+        let content = analysis.db.file_text(position.file_id);
+        let hovered_element = &content[hover.range];
+        let actual = format!("*{}*\n{}\n", hovered_element, hover.info.markup);
+        expect.assert_eq(&actual)
+    }
+    fn check_hover_no_markdown(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = fixture::position(ra_fixture);
+        let hover = analysis.hover(position, true, false).unwrap().unwrap();
        let content = analysis.db.file_text(position.file_id);
        let hovered_element = &content[hover.range];
@@ -410,7 +432,7 @@ mod tests {
    fn check_actions(ra_fixture: &str, expect: Expect) {
        let (analysis, position) = fixture::position(ra_fixture);
-        let hover = analysis.hover(position, true).unwrap().unwrap();
+        let hover = analysis.hover(position, true, true).unwrap().unwrap();
        expect.assert_debug_eq(&hover.info.actions)
    }
@@ -434,6 +456,23 @@ fn main() {
    }
    #[test]
+    fn hover_remove_markdown_if_configured() {
+        check_hover_no_markdown(
+            r#"
+pub fn foo() -> u32 { 1 }
+fn main() {
+    let foo_test = foo()<|>;
+}
+"#,
+            expect![[r#"
+                *foo()*
+                u32
+            "#]],
+        );
+    }
+    #[test]
    fn hover_shows_long_type_of_an_expression() {
        check(
            r#"
@@ -3163,4 +3202,34 @@ fn main() { let s<|>t = test().get(); }
            "#]],
        );
    }
+    #[test]
+    fn hover_displays_normalized_crate_names() {
+        check(
+            r#"
+//- /lib.rs crate:name-with-dashes
+pub mod wrapper {
+    pub struct Thing { x: u32 }
+    impl Thing {
+        pub fn new() -> Thing { Thing { x: 0 } }
+    }
+}
+//- /main.rs crate:main deps:name-with-dashes
+fn main() { let foo_test = name_with_dashes::wrapper::Thing::new<|>(); }
+"#,
+            expect![[r#"
+            *new*
+            ```rust
+            name_with_dashes::wrapper::Thing
+            ```
+            ```rust
+            pub fn new() -> Thing
+            ```
+            "#]],
+        )
+    }
 }
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 1d7e8de56..7d716577e 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -1,4 +1,5 @@
-use hir::{Adt, Callable, HirDisplay, Semantics, Type};
+use assists::utils::FamousDefs;
+use hir::{known, HirDisplay, Semantics};
 use ide_db::RootDatabase;
 use stdx::to_lower_snake_case;
 use syntax::{
@@ -119,17 +120,18 @@ fn get_chaining_hints(
            return None;
        }
        if matches!(expr, ast::Expr::PathExpr(_)) {
-            if let Some(Adt::Struct(st)) = ty.as_adt() {
+            if let Some(hir::Adt::Struct(st)) = ty.as_adt() {
                if st.fields(sema.db).is_empty() {
                    return None;
                }
            }
        }
-        let label = ty.display_truncated(sema.db, config.max_length).to_string();
        acc.push(InlayHint {
            range: expr.syntax().text_range(),
            kind: InlayKind::ChainingHint,
-            label: label.into(),
+            label: hint_iterator(sema, config, &ty).unwrap_or_else(|| {
+                ty.display_truncated(sema.db, config.max_length).to_string().into()
+            }),
        });
    }
    Some(())
@@ -192,17 +194,58 @@ fn get_bind_pat_hints(
    if should_not_display_type_hint(sema, &pat, &ty) {
        return None;
    }
    acc.push(InlayHint {
        range: pat.syntax().text_range(),
        kind: InlayKind::TypeHint,
-        label: ty.display_truncated(sema.db, config.max_length).to_string().into(),
+        label: hint_iterator(sema, config, &ty)
+            .unwrap_or_else(|| ty.display_truncated(sema.db, config.max_length).to_string().into()),
    });
    Some(())
 }
-fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::IdentPat, pat_ty: &Type) -> bool {
+/// Checks if the type is an Iterator from std::iter and replaces its hint with an `impl Iterator<Item = Ty>`.
-    if let Some(Adt::Enum(enum_data)) = pat_ty.as_adt() {
+fn hint_iterator(
+    sema: &Semantics<RootDatabase>,
+    config: &InlayHintsConfig,
+    ty: &hir::Type,
+) -> Option<SmolStr> {
+    let db = sema.db;
+    let strukt = std::iter::successors(Some(ty.clone()), |ty| ty.remove_ref())
+        .last()
+        .and_then(|strukt| strukt.as_adt())?;
+    let krate = strukt.krate(db)?;
+    if krate.declaration_name(db).as_deref() != Some("core") {
+        return None;
+    }
+    let iter_trait = FamousDefs(sema, krate).core_iter_Iterator()?;
+    let iter_mod = FamousDefs(sema, krate).core_iter()?;
+    // assert this type comes from `core::iter`
+    iter_mod.visibility_of(db, &iter_trait.into()).filter(|&vis| vis == hir::Visibility::Public)?;
+    if ty.impls_trait(db, iter_trait, &[]) {
+        let assoc_type_item = iter_trait.items(db).into_iter().find_map(|item| match item {
+            hir::AssocItem::TypeAlias(alias) if alias.name(db) == known::Item => Some(alias),
+            _ => None,
+        })?;
+        if let Some(ty) = ty.normalize_trait_assoc_type(db, iter_trait, &[], assoc_type_item) {
+            const LABEL_START: &str = "impl Iterator<Item = ";
+            const LABEL_END: &str = ">";
+            let ty_display = ty.display_truncated(
+                db,
+                config
+                    .max_length
+                    .map(|len| len.saturating_sub(LABEL_START.len() + LABEL_END.len())),
+            );
+            return Some(format!("{}{}{}", LABEL_START, ty_display, LABEL_END).into());
+        }
+    }
+    None
+}
+fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::IdentPat, pat_ty: &hir::Type) -> bool {
+    if let Some(hir::Adt::Enum(enum_data)) = pat_ty.as_adt() {
        let pat_text = bind_pat.to_string();
        enum_data
            .variants(db)
@@ -217,7 +260,7 @@ fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::IdentPat, pat_ty: &Typ
 fn should_not_display_type_hint(
    sema: &Semantics<RootDatabase>,
    bind_pat: &ast::IdentPat,
-    pat_ty: &Type,
+    pat_ty: &hir::Type,
 ) -> bool {
    let db = sema.db;
@@ -225,7 +268,7 @@ fn should_not_display_type_hint(
        return true;
    }
-    if let Some(Adt::Struct(s)) = pat_ty.as_adt() {
+    if let Some(hir::Adt::Struct(s)) = pat_ty.as_adt() {
        if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.to_string() {
            return true;
        }
@@ -269,7 +312,7 @@ fn should_not_display_type_hint(
 fn should_show_param_name_hint(
    sema: &Semantics<RootDatabase>,
-    callable: &Callable,
+    callable: &hir::Callable,
    param_name: &str,
    argument: &ast::Expr,
 ) -> bool {
@@ -316,7 +359,7 @@ fn is_enum_name_similar_to_param_name(
    param_name: &str,
 ) -> bool {
    match sema.type_of_expr(argument).and_then(|t| t.as_adt()) {
-        Some(Adt::Enum(e)) => to_lower_snake_case(&e.name(sema.db).to_string()) == param_name,
+        Some(hir::Adt::Enum(e)) => to_lower_snake_case(&e.name(sema.db).to_string()) == param_name,
        _ => false,
    }
 }
@@ -337,7 +380,7 @@ fn is_obvious_param(param_name: &str) -> bool {
    param_name.len() == 1 || is_obvious_param_name
 }
-fn get_callable(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<Callable> {
+fn get_callable(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<hir::Callable> {
    match expr {
        ast::Expr::CallExpr(expr) => sema.type_of_expr(&expr.expr()?)?.as_callable(sema.db),
        ast::Expr::MethodCallExpr(expr) => sema.resolve_method_call_as_callable(expr),
@@ -347,6 +390,7 @@ fn get_callable(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<Call
 #[cfg(test)]
 mod tests {
+    use assists::utils::FamousDefs;
    use expect_test::{expect, Expect};
    use test_utils::extract_annotations;
@@ -357,7 +401,9 @@ mod tests {
    }
    fn check_with_config(config: InlayHintsConfig, ra_fixture: &str) {
-        let (analysis, file_id) = fixture::file(ra_fixture);
+        let ra_fixture =
+            format!("//- /main.rs crate:main deps:core\n{}\n{}", ra_fixture, FamousDefs::FIXTURE);
+        let (analysis, file_id) = fixture::file(&ra_fixture);
        let expected = extract_annotations(&*analysis.file_text(file_id).unwrap());
        let inlay_hints = analysis.inlay_hints(file_id, &config).unwrap();
        let actual =
@@ -366,7 +412,9 @@ mod tests {
    }
    fn check_expect(config: InlayHintsConfig, ra_fixture: &str, expect: Expect) {
-        let (analysis, file_id) = fixture::file(ra_fixture);
+        let ra_fixture =
+            format!("//- /main.rs crate:main deps:core\n{}\n{}", ra_fixture, FamousDefs::FIXTURE);
+        let (analysis, file_id) = fixture::file(&ra_fixture);
        let inlay_hints = analysis.inlay_hints(file_id, &config).unwrap();
        expect.assert_debug_eq(&inlay_hints)
    }
@@ -798,12 +846,12 @@ fn main() {
            expect![[r#"
                [
                    InlayHint {
-                        range: 147..172,
+                        range: 148..173,
                        kind: ChainingHint,
                        label: "B",
                    },
                    InlayHint {
-                        range: 147..154,
+                        range: 148..155,
                        kind: ChainingHint,
                        label: "A",
                    },
@@ -864,12 +912,12 @@ fn main() {
            expect![[r#"
                [
                    InlayHint {
-                        range: 143..190,
+                        range: 144..191,
                        kind: ChainingHint,
                        label: "C",
                    },
                    InlayHint {
-                        range: 143..179,
+                        range: 144..180,
                        kind: ChainingHint,
                        label: "B",
                    },
@@ -909,12 +957,12 @@ fn main() {
            expect![[r#"
                [
                    InlayHint {
-                        range: 246..283,
+                        range: 247..284,
                        kind: ChainingHint,
                        label: "B<X<i32, bool>>",
                    },
                    InlayHint {
-                        range: 246..265,
+                        range: 247..266,
                        kind: ChainingHint,
                        label: "A<X<i32, bool>>",
                    },
@@ -935,7 +983,6 @@ fn main() {
        );
        check(
            r#"
-//- /main.rs crate:main deps:core
 pub struct Vec<T> {}
 impl<T> Vec<T> {
@@ -956,13 +1003,6 @@ fn main() {
    println!("Unit expr");
 }
-//- /core.rs crate:core
-#[prelude_import] use iter::*;
-mod iter {
-    trait IntoIterator {
-        type Item;
-    }
-}
 //- /alloc.rs crate:alloc deps:core
 mod collections {
    struct Vec<T> {}
@@ -982,7 +1022,6 @@ mod collections {
    fn complete_for_hint() {
        check(
            r#"
-//- /main.rs crate:main deps:core
 pub struct Vec<T> {}
 impl<T> Vec<T> {
@@ -1004,14 +1043,6 @@ fn main() {
        //^ &str
    }
 }
-//- /core.rs crate:core
-#[prelude_import] use iter::*;
-mod iter {
-    trait IntoIterator {
-        type Item;
-    }
-}
 //- /alloc.rs crate:alloc deps:core
 mod collections {
    struct Vec<T> {}
@@ -1026,4 +1057,130 @@ mod collections {
 "#,
        );
    }
+    #[test]
+    fn multi_dyn_trait_bounds() {
+        check_with_config(
+            InlayHintsConfig {
+                type_hints: true,
+                parameter_hints: false,
+                chaining_hints: false,
+                max_length: None,
+            },
+            r#"
+pub struct Vec<T> {}
+impl<T> Vec<T> {
+    pub fn new() -> Self { Vec {} }
+}
+pub struct Box<T> {}
+trait Display {}
+trait Sync {}
+fn main() {
+    let _v = Vec::<Box<&(dyn Display + Sync)>>::new();
+      //^^ Vec<Box<&(dyn Display + Sync)>>
+    let _v = Vec::<Box<*const (dyn Display + Sync)>>::new();
+      //^^ Vec<Box<*const (dyn Display + Sync)>>
+    let _v = Vec::<Box<dyn Display + Sync>>::new();
+      //^^ Vec<Box<dyn Display + Sync>>
+}
+"#,
+        );
+    }
+    #[test]
+    fn shorten_iterator_hints() {
+        check_with_config(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: true,
+                chaining_hints: false,
+                max_length: None,
+            },
+            r#"
+use core::iter;
+struct MyIter;
+impl Iterator for MyIter {
+    type Item = ();
+    fn next(&mut self) -> Option<Self::Item> {
+        None
+    }
+}
+fn main() {
+    let _x = MyIter;
+      //^^ MyIter
+    let _x = iter::repeat(0);
+      //^^ impl Iterator<Item = i32>
+    fn generic<T: Clone>(t: T) {
+        let _x = iter::repeat(t);
+          //^^ impl Iterator<Item = T>
+        let _chained = iter::repeat(t).take(10);
+          //^^^^^^^^ impl Iterator<Item = T>
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn shorten_iterator_chaining_hints() {
+        check_expect(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
+            r#"
+use core::iter;
+struct MyIter;
+impl Iterator for MyIter {
+    type Item = ();
+    fn next(&mut self) -> Option<Self::Item> {
+        None
+    }
+}
+fn main() {
+    let _x = MyIter.by_ref()
+        .take(5)
+        .by_ref()
+        .take(5)
+        .by_ref();
+}
+"#,
+            expect![[r#"
+                [
+                    InlayHint {
+                        range: 175..242,
+                        kind: ChainingHint,
+                        label: "impl Iterator<Item = ()>",
+                    },
+                    InlayHint {
+                        range: 175..225,
+                        kind: ChainingHint,
+                        label: "impl Iterator<Item = ()>",
+                    },
+                    InlayHint {
+                        range: 175..207,
+                        kind: ChainingHint,
+                        label: "impl Iterator<Item = ()>",
+                    },
+                    InlayHint {
+                        range: 175..190,
+                        kind: ChainingHint,
+                        label: "&mut MyIter",
+                    },
+                ]
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 1aa673cf8..57f3581b6 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -46,6 +46,7 @@ mod syntax_highlighting;
 mod syntax_tree;
 mod typing;
 mod link_rewrite;
+mod markdown_remove;
 use std::sync::Arc;
@@ -376,8 +377,9 @@ impl Analysis {
        &self,
        position: FilePosition,
        links_in_hover: bool,
+        markdown: bool,
    ) -> Cancelable<Option<RangeInfo<HoverResult>>> {
-        self.with_db(|db| hover::hover(db, position, links_in_hover))
+        self.with_db(|db| hover::hover(db, position, links_in_hover, markdown))
    }
    /// Computes parameter information for the given call expression.
diff --git a/crates/ide/src/link_rewrite.rs b/crates/ide/src/link_rewrite.rs
index a16f90e17..c317a2379 100644
--- a/crates/ide/src/link_rewrite.rs
+++ b/crates/ide/src/link_rewrite.rs
@@ -107,7 +107,7 @@ fn rewrite_intra_doc_link(
    let krate = resolved.module(db)?.krate();
    let canonical_path = resolved.canonical_path(db)?;
    let new_target = get_doc_url(db, &krate)?
-        .join(&format!("{}/", krate.display_name(db)?))
+        .join(&format!("{}/", krate.declaration_name(db)?))
        .ok()?
        .join(&canonical_path.replace("::", "/"))
        .ok()?
@@ -127,7 +127,7 @@ fn rewrite_url_link(db: &RootDatabase, def: ModuleDef, target: &str) -> Option<S
    let module = def.module(db)?;
    let krate = module.krate();
    let canonical_path = def.canonical_path(db)?;
-    let base = format!("{}/{}", krate.display_name(db)?, canonical_path.replace("::", "/"));
+    let base = format!("{}/{}", krate.declaration_name(db)?, canonical_path.replace("::", "/"));
    get_doc_url(db, &krate)
        .and_then(|url| url.join(&base).ok())
@@ -248,7 +248,7 @@ fn get_doc_url(db: &RootDatabase, krate: &Crate) -> Option<Url> {
            //
            // FIXME: clicking on the link should just open the file in the editor,
            // instead of falling back to external urls.
-            Some(format!("https://docs.rs/{}/*/", krate.display_name(db)?))
+            Some(format!("https://docs.rs/{}/*/", krate.declaration_name(db)?))
        })
        .and_then(|s| Url::parse(&s).ok())
 }
diff --git a/crates/ide/src/markdown_remove.rs b/crates/ide/src/markdown_remove.rs
new file mode 100644
index 000000000..02ad39dfb
--- /dev/null
+++ b/crates/ide/src/markdown_remove.rs
@@ -0,0 +1,23 @@
+//! Removes markdown from strings.
+use pulldown_cmark::{Event, Parser, Tag};
+/// Removes all markdown, keeping the text and code blocks
+///
+/// Currently limited in styling, i.e. no ascii tables or lists
+pub fn remove_markdown(markdown: &str) -> String {
+    let mut out = String::new();
+    let parser = Parser::new(markdown);
+    for event in parser {
+        match event {
+            Event::Text(text) | Event::Code(text) => out.push_str(&text),
+            Event::SoftBreak | Event::HardBreak | Event::Rule | Event::End(Tag::CodeBlock(_)) => {
+                out.push('\n')
+            }
+            _ => {}
+        }
+    }
+    out
+}
diff --git a/crates/ide/src/status.rs b/crates/ide/src/status.rs
index 0af84daa0..f67f10491 100644
--- a/crates/ide/src/status.rs
+++ b/crates/ide/src/status.rs
@@ -45,7 +45,7 @@ pub(crate) fn status(db: &RootDatabase, file_id: Option<FileId>) -> String {
        match krate {
            Some(krate) => {
                let crate_graph = db.crate_graph();
-                let display_crate = |krate: CrateId| match &crate_graph[krate].display_name {
+                let display_crate = |krate: CrateId| match &crate_graph[krate].declaration_name {
                    Some(it) => format!("{}({:?})", it, krate),
                    None => format!("{:?}", krate),
                };
diff --git a/crates/ide/src/typing/on_enter.rs b/crates/ide/src/typing/on_enter.rs
index a0dc4b9df..98adef1d6 100644
--- a/crates/ide/src/typing/on_enter.rs
+++ b/crates/ide/src/typing/on_enter.rs
@@ -51,12 +51,12 @@ pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<Text
        return None;
    }
-    let mut remove_last_space = false;
+    let mut remove_trailing_whitespace = false;
    // Continuing single-line non-doc comments (like this one :) ) is annoying
    if prefix == "//" && comment_range.end() == position.offset {
        if comment.text().ends_with(' ') {
            mark::hit!(continues_end_of_line_comment_with_space);
-            remove_last_space = true;
+            remove_trailing_whitespace = true;
        } else if !followed_by_comment(&comment) {
            return None;
        }
@@ -64,8 +64,10 @@ pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<Text
    let indent = node_indent(&file, comment.syntax())?;
    let inserted = format!("\n{}{} $0", indent, prefix);
-    let delete = if remove_last_space {
+    let delete = if remove_trailing_whitespace {
-        TextRange::new(position.offset - TextSize::of(' '), position.offset)
+        let trimmed_len = comment.text().trim_end().len() as u32;
+        let trailing_whitespace_len = comment.text().len() as u32 - trimmed_len;
+        TextRange::new(position.offset - TextSize::from(trailing_whitespace_len), position.offset)
    } else {
        TextRange::empty(position.offset)
    };
@@ -253,4 +255,23 @@ fn main() {
 "#,
        );
    }
+    #[test]
+    fn trims_all_trailing_whitespace() {
+        do_check(
+            "
+fn main() {
+    // Fix me  \t\t   <|>
+    let x = 1 + 1;
+}
+",
+            "
+fn main() {
+    // Fix me
+    // $0
+    let x = 1 + 1;
+}
+",
+        );
+    }
 }
diff --git a/crates/mbe/src/subtree_source.rs b/crates/mbe/src/subtree_source.rs
index 41461b315..396ce8b16 100644
--- a/crates/mbe/src/subtree_source.rs
+++ b/crates/mbe/src/subtree_source.rs
@@ -155,9 +155,14 @@ fn convert_delim(d: Option<tt::DelimiterKind>, closing: bool) -> TtToken {
 }
 fn convert_literal(l: &tt::Literal) -> TtToken {
-    let kind = lex_single_syntax_kind(&l.text)
+    let is_negated = l.text.starts_with('-');
+    let inner_text = &l.text[if is_negated { 1 } else { 0 }..];
+    let kind = lex_single_syntax_kind(inner_text)
        .map(|(kind, _error)| kind)
-        .filter(|kind| kind.is_literal())
+        .filter(|kind| {
+            kind.is_literal() && (!is_negated || matches!(kind, FLOAT_NUMBER | INT_NUMBER))
+        })
        .unwrap_or_else(|| panic!("Fail to convert given literal {:#?}", &l));
    TtToken { kind, is_joint_to_next: false, text: l.text.clone() }
@@ -195,3 +200,24 @@ fn convert_leaf(leaf: &tt::Leaf) -> TtToken {
        tt::Leaf::Punct(punct) => convert_punct(*punct),
    }
 }
+#[cfg(test)]
+mod tests {
+    use super::{convert_literal, TtToken};
+    use syntax::{SmolStr, SyntaxKind};
+    #[test]
+    fn test_negative_literal() {
+        assert_eq!(
+            convert_literal(&tt::Literal {
+                id: tt::TokenId::unspecified(),
+                text: SmolStr::new("-42.0")
+            }),
+            TtToken {
+                kind: SyntaxKind::FLOAT_NUMBER,
+                is_joint_to_next: false,
+                text: SmolStr::new("-42.0")
+            }
+        );
+    }
+}
diff --git a/crates/project_model/src/lib.rs b/crates/project_model/src/lib.rs
index 258f60e28..d1e7602fc 100644
--- a/crates/project_model/src/lib.rs
+++ b/crates/project_model/src/lib.rs
@@ -411,7 +411,7 @@ impl ProjectWorkspace {
                            let crate_id = crate_graph.add_crate_root(
                                file_id,
                                edition,
-                                Some(cargo[pkg].name.clone()),
+                                Some(CrateName::normalize_dashes(&cargo[pkg].name)),
                                cfg_options,
                                env,
                                proc_macro.clone(),
@@ -546,7 +546,8 @@ fn sysroot_to_crate_graph(
            let env = Env::default();
            let proc_macro = vec![];
-            let name = sysroot[krate].name.clone();
+            let name = CrateName::new(&sysroot[krate].name)
+                .expect("Sysroot crates' names do not contain dashes");
            let crate_id = crate_graph.add_crate_root(
                file_id,
                Edition::Edition2018,
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
index f3b6c900e..d1d3b12f8 100644
--- a/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -36,11 +36,12 @@ pub fn diagnostics(path: &Path, load_output_dirs: bool, with_proc_macro: bool) -
    for module in work {
        let file_id = module.definition_source(db).file_id.original_file(db);
        if !visited_files.contains(&file_id) {
-            let crate_name = if let Some(name) = module.krate().display_name(db) {
+            let crate_name = module
-                format!("{}", name)
+                .krate()
-            } else {
+                .declaration_name(db)
-                String::from("unknown")
+                .as_ref()
-            };
+                .map(ToString::to_string)
+                .unwrap_or_else(|| "unknown".to_string());
            println!("processing crate: {}, module: {}", crate_name, _vfs.file_path(file_id));
            for diagnostic in analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap()
            {
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 0ab4c37bf..1b9b24698 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -10,11 +10,12 @@
 use std::{ffi::OsString, path::PathBuf};
 use flycheck::FlycheckConfig;
+use hir::PrefixKind;
 use ide::{
    AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig,
    MergeBehaviour,
 };
-use lsp_types::ClientCapabilities;
+use lsp_types::{ClientCapabilities, MarkupKind};
 use project_model::{CargoConfig, ProjectJson, ProjectJsonData, ProjectManifest};
 use rustc_hash::FxHashSet;
 use serde::Deserialize;
@@ -289,6 +290,11 @@ impl Config {
            MergeBehaviourDef::Full => Some(MergeBehaviour::Full),
            MergeBehaviourDef::Last => Some(MergeBehaviour::Last),
        };
+        self.assist.insert_use.prefix_kind = match data.assist_importPrefix {
+            ImportPrefixDef::Plain => PrefixKind::Plain,
+            ImportPrefixDef::ByCrate => PrefixKind::ByCrate,
+            ImportPrefixDef::BySelf => PrefixKind::BySelf,
+        };
        self.call_info_full = data.callInfo_full;
@@ -327,6 +333,7 @@ impl Config {
            debug: data.hoverActions_enable && data.hoverActions_debug,
            goto_type_def: data.hoverActions_enable && data.hoverActions_gotoTypeDef,
            links_in_hover: data.hoverActions_linksInHover,
+            markdown: true,
        };
        log::info!("Config::update() = {:#?}", self);
@@ -334,6 +341,9 @@ impl Config {
    pub fn update_caps(&mut self, caps: &ClientCapabilities) {
        if let Some(doc_caps) = caps.text_document.as_ref() {
+            if let Some(value) = doc_caps.hover.as_ref().and_then(|it| it.content_format.as_ref()) {
+                self.hover.markdown = value.contains(&MarkupKind::Markdown)
+            }
            if let Some(value) = doc_caps.definition.as_ref().and_then(|it| it.link_support) {
                self.client_caps.location_link = value;
            }
@@ -403,13 +413,21 @@ enum ManifestOrProjectJson {
 }
 #[derive(Deserialize)]
-#[serde(rename_all = "lowercase")]
+#[serde(rename_all = "snake_case")]
 enum MergeBehaviourDef {
    None,
    Full,
    Last,
 }
+#[derive(Deserialize)]
+#[serde(rename_all = "snake_case")]
+enum ImportPrefixDef {
+    Plain,
+    BySelf,
+    ByCrate,
+}
 macro_rules! config_data {
    (struct $name:ident { $($field:ident: $ty:ty = $default:expr,)*}) => {
        #[allow(non_snake_case)]
@@ -434,6 +452,7 @@ macro_rules! config_data {
 config_data! {
    struct ConfigData {
        assist_importMergeBehaviour: MergeBehaviourDef = MergeBehaviourDef::None,
+        assist_importPrefix: ImportPrefixDef           = ImportPrefixDef::Plain,
        callInfo_full: bool = true,
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index e970abb7c..468655f9c 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -618,7 +618,11 @@ pub(crate) fn handle_hover(
 ) -> Result<Option<lsp_ext::Hover>> {
    let _p = profile::span("handle_hover");
    let position = from_proto::file_position(&snap, params.text_document_position_params)?;
-    let info = match snap.analysis.hover(position, snap.config.hover.links_in_hover)? {
+    let info = match snap.analysis.hover(
+        position,
+        snap.config.hover.links_in_hover,
+        snap.config.hover.markdown,
+    )? {
        None => return Ok(None),
        Some(info) => info,
    };
diff --git a/crates/rust-analyzer/src/lsp_utils.rs b/crates/rust-analyzer/src/lsp_utils.rs
index 85c661571..bd888f634 100644
--- a/crates/rust-analyzer/src/lsp_utils.rs
+++ b/crates/rust-analyzer/src/lsp_utils.rs
@@ -25,8 +25,9 @@ pub(crate) enum Progress {
 }
 impl Progress {
-    pub(crate) fn percentage(done: usize, total: usize) -> f64 {
+    pub(crate) fn fraction(done: usize, total: usize) -> f64 {
-        (done as f64 / total.max(1) as f64) * 100.0
+        assert!(done <= total);
+        done as f64 / total.max(1) as f64
    }
 }
@@ -43,11 +44,15 @@ impl GlobalState {
        title: &str,
        state: Progress,
        message: Option<String>,
-        percentage: Option<f64>,
+        fraction: Option<f64>,
    ) {
        if !self.config.client_caps.work_done_progress {
            return;
        }
+        let percentage = fraction.map(|f| {
+            assert!(0.0 <= f && f <= 1.0);
+            f * 100.0
+        });
        let token = lsp_types::ProgressToken::String(format!("rustAnalyzer/{}", title));
        let work_done_progress = match state {
            Progress::Begin => {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index c2d0ac791..4b7ac8224 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -230,7 +230,7 @@ impl GlobalState {
                                    "roots scanned",
                                    state,
                                    Some(format!("{}/{}", n_done, n_total)),
-                                    Some(Progress::percentage(n_done, n_total)),
+                                    Some(Progress::fraction(n_done, n_total)),
                                )
                            }
                        }
diff --git a/crates/syntax/src/parsing/lexer.rs b/crates/syntax/src/parsing/lexer.rs
index f1202113b..7e38c32cc 100644
--- a/crates/syntax/src/parsing/lexer.rs
+++ b/crates/syntax/src/parsing/lexer.rs
@@ -1,10 +1,10 @@
 //! Lexer analyzes raw input string and produces lexemes (tokens).
 //! It is just a bridge to `rustc_lexer`.
-use rustc_lexer::{LiteralKind as LK, RawStrError};
 use std::convert::TryInto;
+use rustc_lexer::{LiteralKind as LK, RawStrError};
 use crate::{
    SyntaxError,
    SyntaxKind::{self, *},
@@ -61,17 +61,18 @@ pub fn tokenize(text: &str) -> (Vec<Token>, Vec<SyntaxError>) {
    (tokens, errors)
 }
-/// Returns `SyntaxKind` and `Option<SyntaxError>` of the first token
+/// Returns `SyntaxKind` and `Option<SyntaxError>` if `text` parses as a single token.
-/// encountered at the beginning of the string.
 ///
 /// Returns `None` if the string contains zero *or two or more* tokens.
 /// The token is malformed if the returned error is not `None`.
 ///
 /// Beware that unescape errors are not checked at tokenization time.
 pub fn lex_single_syntax_kind(text: &str) -> Option<(SyntaxKind, Option<SyntaxError>)> {
-    lex_first_token(text)
+    let (first_token, err) = lex_first_token(text)?;
-        .filter(|(token, _)| token.len == TextSize::of(text))
+    if first_token.len != TextSize::of(text) {
-        .map(|(token, error)| (token.kind, error))
+        return None;
+    }
+    Some((first_token.kind, err))
 }
 /// The same as `lex_single_syntax_kind()` but returns only `SyntaxKind` and
@@ -79,9 +80,11 @@ pub fn lex_single_syntax_kind(text: &str) -> Option<(SyntaxKind, Option<SyntaxEr
 ///
 /// Beware that unescape errors are not checked at tokenization time.
 pub fn lex_single_valid_syntax_kind(text: &str) -> Option<SyntaxKind> {
-    lex_first_token(text)
+    let (single_token, err) = lex_single_syntax_kind(text)?;
-        .filter(|(token, error)| !error.is_some() && token.len == TextSize::of(text))
+    if err.is_some() {
-        .map(|(token, _error)| token.kind)
+        return None;
+    }
+    Some(single_token)
 }
 /// Returns `SyntaxKind` and `Option<SyntaxError>` of the first token
diff --git a/crates/syntax/src/ptr.rs b/crates/syntax/src/ptr.rs
index ca7957747..d3fb7a5d9 100644
--- a/crates/syntax/src/ptr.rs
+++ b/crates/syntax/src/ptr.rs
@@ -12,6 +12,8 @@ use crate::{AstNode, SyntaxKind, SyntaxNode, TextRange};
 /// specific node across reparses of the same file.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SyntaxNodePtr {
+    // Don't expose this field further. At some point, we might want to replace
+    // range with node id.
    pub(crate) range: TextRange,
    kind: SyntaxKind,
 }
diff --git a/crates/syntax/src/validation.rs b/crates/syntax/src/validation.rs
index 2dddaf09a..0f9a5e8ae 100644
--- a/crates/syntax/src/validation.rs
+++ b/crates/syntax/src/validation.rs
@@ -3,10 +3,11 @@
 mod block;
 use crate::{
-    ast, match_ast, AstNode, SyntaxError,
+    algo, ast, match_ast, AstNode, SyntaxError,
    SyntaxKind::{BYTE, BYTE_STRING, CHAR, CONST, FN, INT_NUMBER, STRING, TYPE_ALIAS},
    SyntaxNode, SyntaxToken, TextSize, T,
 };
+use rowan::Direction;
 use rustc_lexer::unescape::{
    self, unescape_byte, unescape_byte_literal, unescape_char, unescape_literal, Mode,
 };
@@ -95,6 +96,9 @@ pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> {
                ast::Visibility(it) => validate_visibility(it, &mut errors),
                ast::RangeExpr(it) => validate_range_expr(it, &mut errors),
                ast::PathSegment(it) => validate_path_keywords(it, &mut errors),
+                ast::RefType(it) => validate_trait_object_ref_ty(it, &mut errors),
+                ast::PtrType(it) => validate_trait_object_ptr_ty(it, &mut errors),
+                ast::FnPtrType(it) => validate_trait_object_fn_ptr_ret_ty(it, &mut errors),
                _ => (),
            }
        }
@@ -301,3 +305,42 @@ fn validate_path_keywords(segment: ast::PathSegment, errors: &mut Vec<SyntaxErro
        return true;
    }
 }
+fn validate_trait_object_ref_ty(ty: ast::RefType, errors: &mut Vec<SyntaxError>) {
+    if let Some(ast::Type::DynTraitType(ty)) = ty.ty() {
+        if let Some(err) = validate_trait_object_ty(ty) {
+            errors.push(err);
+        }
+    }
+}
+fn validate_trait_object_ptr_ty(ty: ast::PtrType, errors: &mut Vec<SyntaxError>) {
+    if let Some(ast::Type::DynTraitType(ty)) = ty.ty() {
+        if let Some(err) = validate_trait_object_ty(ty) {
+            errors.push(err);
+        }
+    }
+}
+fn validate_trait_object_fn_ptr_ret_ty(ty: ast::FnPtrType, errors: &mut Vec<SyntaxError>) {
+    if let Some(ast::Type::DynTraitType(ty)) = ty.ret_type().and_then(|ty| ty.ty()) {
+        if let Some(err) = validate_trait_object_ty(ty) {
+            errors.push(err);
+        }
+    }
+}
+fn validate_trait_object_ty(ty: ast::DynTraitType) -> Option<SyntaxError> {
+    let tbl = ty.type_bound_list()?;
+    if tbl.bounds().count() > 1 {
+        let dyn_token = ty.dyn_token()?;
+        let potential_parentheses =
+            algo::skip_trivia_token(dyn_token.prev_token()?, Direction::Prev)?;
+        let kind = potential_parentheses.kind();
+        if !matches!(kind, T!['('] | T![<] | T![=]) {
+            return Some(SyntaxError::new("ambiguous `+` in a type", ty.syntax().text_range()));
+        }
+    }
+    None
+}
diff --git a/crates/syntax/test_data/parser/err/0046_ambiguous_trait_object.rast b/crates/syntax/test_data/parser/err/0046_ambiguous_trait_object.rast
new file mode 100644
index 000000000..592741cdb
--- /dev/null
+++ b/crates/syntax/test_data/parser/err/0046_ambiguous_trait_object.rast
@@ -0,0 +1,192 @@
+[email protected]
+  [email protected]
+    [email protected] "type"
+    [email protected] " "
+    [email protected]
+      [email protected] "Foo"
+    [email protected]
+      [email protected] "<"
+      [email protected]
+        [email protected] "\'a"
+      [email protected] ">"
+    [email protected] " "
+    [email protected] "="
+    [email protected] " "
+    [email protected]
+      [email protected] "&"
+      [email protected] "\'a"
+      [email protected] " "
+      [email protected]
+        [email protected] "dyn"
+        [email protected] " "
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected] "Send"
+          [email protected] " "
+          [email protected] "+"
+          [email protected] " "
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected] "Sync"
+    [email protected] ";"
+  [email protected] "\n"
+  [email protected]
+    [email protected] "type"
+    [email protected] " "
+    [email protected]
+      [email protected] "Foo"
+    [email protected] " "
+    [email protected] "="
+    [email protected] " "
+    [email protected]
+      [email protected] "*"
+      [email protected] "const"
+      [email protected] " "
+      [email protected]
+        [email protected] "dyn"
+        [email protected] " "
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected] "Send"
+          [email protected] " "
+          [email protected] "+"
+          [email protected] " "
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected] "Sync"
+    [email protected] ";"
+  [email protected] "\n"
+  [email protected]
+    [email protected] "type"
+    [email protected] " "
+    [email protected]
+      [email protected] "Foo"
+    [email protected] " "
+    [email protected] "="
+    [email protected] " "
+    [email protected]
+      [email protected] "fn"
+      [email protected]
+        [email protected] "("
+        [email protected] ")"
+      [email protected] " "
+      [email protected]
+        [email protected] "->"
+        [email protected] " "
+        [email protected]
+          [email protected] "dyn"
+          [email protected] " "
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected] "Send"
+            [email protected] " "
+            [email protected] "+"
+            [email protected] " "
+            [email protected]
+              [email protected] "\'static"
+    [email protected] ";"
+  [email protected] "\n"
+  [email protected]
+    [email protected] "fn"
+    [email protected] " "
+    [email protected]
+      [email protected] "main"
+    [email protected]
+      [email protected] "("
+      [email protected] ")"
+    [email protected] " "
+    [email protected]
+      [email protected] "{"
+      [email protected] "\n    "
+      [email protected]
+        [email protected] "let"
+        [email protected] " "
+        [email protected]
+          [email protected]
+            [email protected] "b"
+        [email protected] " "
+        [email protected] "="
+        [email protected] " "
+        [email protected]
+          [email protected]
+            [email protected] "("
+            [email protected]
+              [email protected] "&"
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected] "a"
+            [email protected] ")"
+          [email protected] " "
+          [email protected] "as"
+          [email protected] " "
+          [email protected]
+            [email protected] "&"
+            [email protected]
+              [email protected] "dyn"
+              [email protected] " "
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected]
+                        [email protected]
+                          [email protected] "Add"
+                        [email protected]
+                          [email protected] "<"
+                          [email protected]
+                            [email protected]
+                              [email protected]
+                                [email protected]
+                                  [email protected]
+                                    [email protected] "Other"
+                          [email protected] ","
+                          [email protected] " "
+                          [email protected]
+                            [email protected]
+                              [email protected] "Output"
+                            [email protected] " "
+                            [email protected] "="
+                            [email protected] " "
+                            [email protected]
+                              [email protected]
+                                [email protected]
+                                  [email protected]
+                                    [email protected] "Addable"
+                          [email protected] ">"
+                [email protected] " "
+                [email protected] "+"
+                [email protected] " "
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected]
+                        [email protected]
+                          [email protected] "Other"
+        [email protected] ";"
+      [email protected] "\n"
+      [email protected] "}"
+  [email protected] "\n"
+error 19..34: ambiguous `+` in a type
+error 54..69: ambiguous `+` in a type
+error 90..108: ambiguous `+` in a type
+error 143..183: ambiguous `+` in a type
diff --git a/crates/syntax/test_data/parser/err/0046_ambiguous_trait_object.rs b/crates/syntax/test_data/parser/err/0046_ambiguous_trait_object.rs
new file mode 100644
index 000000000..3a73d81bb
--- /dev/null
+++ b/crates/syntax/test_data/parser/err/0046_ambiguous_trait_object.rs
@@ -0,0 +1,6 @@
+type Foo<'a> = &'a dyn Send + Sync;
+type Foo = *const dyn Send + Sync;
+type Foo = fn() -> dyn Send + 'static;
+fn main() {
+    let b = (&a) as &dyn Add<Other, Output = Addable> + Other;
+}
diff --git a/crates/syntax/test_data/parser/ok/0069_multi_trait_object.rast b/crates/syntax/test_data/parser/ok/0069_multi_trait_object.rast
new file mode 100644
index 000000000..0cd868a83
--- /dev/null
+++ b/crates/syntax/test_data/parser/ok/0069_multi_trait_object.rast
@@ -0,0 +1,200 @@
+[email protected]
+  [email protected]
+    [email protected] "type"
+    [email protected] " "
+    [email protected]
+      [email protected] "Foo"
+    [email protected]
+      [email protected] "<"
+      [email protected]
+        [email protected] "\'a"
+      [email protected] ">"
+    [email protected] " "
+    [email protected] "="
+    [email protected] " "
+    [email protected]
+      [email protected] "&"
+      [email protected] "\'a"
+      [email protected] " "
+      [email protected]
+        [email protected] "("
+        [email protected]
+          [email protected] "dyn"
+          [email protected] " "
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected] "Send"
+            [email protected] " "
+            [email protected] "+"
+            [email protected] " "
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected] "Sync"
+        [email protected] ")"
+    [email protected] ";"
+  [email protected] "\n"
+  [email protected]
+    [email protected] "type"
+    [email protected] " "
+    [email protected]
+      [email protected] "Foo"
+    [email protected] " "
+    [email protected] "="
+    [email protected] " "
+    [email protected]
+      [email protected] "*"
+      [email protected] "const"
+      [email protected] " "
+      [email protected]
+        [email protected] "("
+        [email protected]
+          [email protected] "dyn"
+          [email protected] " "
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected] "Send"
+            [email protected] " "
+            [email protected] "+"
+            [email protected] " "
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected] "Sync"
+        [email protected] ")"
+    [email protected] ";"
+  [email protected] "\n"
+  [email protected]
+    [email protected] "type"
+    [email protected] " "
+    [email protected]
+      [email protected] "Foo"
+    [email protected] " "
+    [email protected] "="
+    [email protected] " "
+    [email protected]
+      [email protected] "fn"
+      [email protected]
+        [email protected] "("
+        [email protected] ")"
+      [email protected] " "
+      [email protected]
+        [email protected] "->"
+        [email protected] " "
+        [email protected]
+          [email protected] "("
+          [email protected]
+            [email protected] "dyn"
+            [email protected] " "
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected]
+                        [email protected] "Send"
+              [email protected] " "
+              [email protected] "+"
+              [email protected] " "
+              [email protected]
+                [email protected] "\'static"
+          [email protected] ")"
+    [email protected] ";"
+  [email protected] "\n"
+  [email protected]
+    [email protected] "fn"
+    [email protected] " "
+    [email protected]
+      [email protected] "main"
+    [email protected]
+      [email protected] "("
+      [email protected] ")"
+    [email protected] " "
+    [email protected]
+      [email protected] "{"
+      [email protected] "\n    "
+      [email protected]
+        [email protected] "let"
+        [email protected] " "
+        [email protected]
+          [email protected]
+            [email protected] "b"
+        [email protected] " "
+        [email protected] "="
+        [email protected] " "
+        [email protected]
+          [email protected]
+            [email protected] "("
+            [email protected]
+              [email protected] "&"
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected] "a"
+            [email protected] ")"
+          [email protected] " "
+          [email protected] "as"
+          [email protected] " "
+          [email protected]
+            [email protected] "&"
+            [email protected]
+              [email protected] "("
+              [email protected]
+                [email protected] "dyn"
+                [email protected] " "
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected]
+                        [email protected]
+                          [email protected]
+                            [email protected] "Add"
+                          [email protected]
+                            [email protected] "<"
+                            [email protected]
+                              [email protected]
+                                [email protected]
+                                  [email protected]
+                                    [email protected]
+                                      [email protected] "Other"
+                            [email protected] ","
+                            [email protected] " "
+                            [email protected]
+                              [email protected]
+                                [email protected] "Output"
+                              [email protected] " "
+                              [email protected] "="
+                              [email protected] " "
+                              [email protected]
+                                [email protected]
+                                  [email protected]
+                                    [email protected]
+                                      [email protected] "Addable"
+                            [email protected] ">"
+                  [email protected] " "
+                  [email protected] "+"
+                  [email protected] " "
+                  [email protected]
+                    [email protected]
+                      [email protected]
+                        [email protected]
+                          [email protected]
+                            [email protected] "Other"
+              [email protected] ")"
+        [email protected] ";"
+      [email protected] "\n"
+      [email protected] "}"
+  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/ok/0069_multi_trait_object.rs b/crates/syntax/test_data/parser/ok/0069_multi_trait_object.rs
new file mode 100644
index 000000000..97eb79c48
--- /dev/null
+++ b/crates/syntax/test_data/parser/ok/0069_multi_trait_object.rs
@@ -0,0 +1,6 @@
+type Foo<'a> = &'a (dyn Send + Sync);
+type Foo = *const (dyn Send + Sync);
+type Foo = fn() -> (dyn Send + 'static);
+fn main() {
+    let b = (&a) as &(dyn Add<Other, Output = Addable> + Other);
+}
diff --git a/docs/dev/style.md b/docs/dev/style.md
index fb407afcd..59067d234 100644
--- a/docs/dev/style.md
+++ b/docs/dev/style.md
@@ -6,7 +6,9 @@ Our approach to "clean code" is two-fold:
 It is explicitly OK for a reviewer to flag only some nits in the PR, and then send a follow-up cleanup PR for things which are easier to explain by example, cc-ing the original author.
 Sending small cleanup PRs (like renaming a single local variable) is encouraged.
-# Scale of Changes
+# General
+## Scale of Changes
 Everyone knows that it's better to send small & focused pull requests.
 The problem is, sometimes you *have* to, eg, rewrite the whole compiler, and that just doesn't fit into a set of isolated PRs.
@@ -45,13 +47,35 @@ That said, adding an innocent-looking `pub use` is a very simple way to break en
 Note: if you enjoyed this abstract hand-waving about boundaries, you might appreciate
 https://www.tedinski.com/2018/02/06/system-boundaries.html
-# Crates.io Dependencies
+## Crates.io Dependencies
 We try to be very conservative with usage of crates.io dependencies.
 Don't use small "helper" crates (exception: `itertools` is allowed).
 If there's some general reusable bit of code you need, consider adding it to the `stdx` crate.
-# Minimal Tests
+## Commit Style
+We don't have specific rules around git history hygiene.
+Maintaining clean git history is strongly encouraged, but not enforced.
+Use rebase workflow, it's OK to rewrite history during PR review process.
+After you are happy with the state of the code, please use [interactive rebase](https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History) to squash fixup commits.
+Avoid @mentioning people in commit messages and pull request descriptions(they are added to commit message by bors).
+Such messages create a lot of duplicate notification traffic during rebases.
+## Clippy
+We don't enforce Clippy.
+A number of default lints have high false positive rate.
+Selectively patching false-positives with `allow(clippy)` is considered worse than not using Clippy at all.
+There's `cargo xtask lint` command which runs a subset of low-FPR lints.
+Careful tweaking of `xtask lint` is welcome.
+See also [rust-lang/clippy#5537](https://github.com/rust-lang/rust-clippy/issues/5537).
+Of course, applying Clippy suggestions is welcome as long as they indeed improve the code.
+# Code
+## Minimal Tests
 Most tests in rust-analyzer start with a snippet of Rust code.
 This snippets should be minimal -- if you copy-paste a snippet of real code into the tests, make sure to remove everything which could be removed.
@@ -65,119 +89,7 @@ There are many benefits to this:
 It also makes sense to format snippets more compactly (for example, by placing enum definitions like `enum E { Foo, Bar }` on a single line),
 as long as they are still readable.
-# Order of Imports
+## Preconditions
-Separate import groups with blank lines.
-Use one `use` per crate.
-```rust
-mod x;
-mod y;
-// First std.
-use std::{ ... }
-// Second, external crates (both crates.io crates and other rust-analyzer crates).
-use crate_foo::{ ... }
-use crate_bar::{ ... }
-// Then current crate.
-use crate::{}
-// Finally, parent and child modules, but prefer `use crate::`.
-use super::{}
-```
-Module declarations come before the imports.
-Order them in "suggested reading order" for a person new to the code base.
-# Import Style
-Qualify items from `hir` and `ast`.
-```rust
-// Good
-use syntax::ast;
-fn frobnicate(func: hir::Function, strukt: ast::StructDef) {}
-// Not as good
-use hir::Function;
-use syntax::ast::StructDef;
-fn frobnicate(func: Function, strukt: StructDef) {}
-```
-Avoid local `use MyEnum::*` imports.
-Prefer `use crate::foo::bar` to `use super::bar`.
-When implementing `Debug` or `Display`, import `std::fmt`:
-```rust
-// Good
-use std::fmt;
-impl fmt::Display for RenameError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { .. }
-}
-// Not as good
-impl std::fmt::Display for RenameError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { .. }
-}
-```
-# Order of Items
-Optimize for the reader who sees the file for the first time, and wants to get a general idea about what's going on.
-People read things from top to bottom, so place most important things first.
-Specifically, if all items except one are private, always put the non-private item on top.
-Put `struct`s and `enum`s first, functions and impls last.
-Do
-```rust
-// Good
-struct Foo {
-    bars: Vec<Bar>
-}
-struct Bar;
-```
-rather than
-```rust
-// Not as good
-struct Bar;
-struct Foo {
-    bars: Vec<Bar>
-}
-```
-# Variable Naming
-Use boring and long names for local variables ([yay code completion](https://github.com/rust-analyzer/rust-analyzer/pull/4162#discussion_r417130973)).
-The default name is a lowercased name of the type: `global_state: GlobalState`.
-Avoid ad-hoc acronyms and contractions, but use the ones that exist consistently (`db`, `ctx`, `acc`).
-Default names:
-* `res` -- "result of the function" local variable
-* `it` -- I don't really care about the name
-* `n_foo` -- number of foos
-* `foo_idx` -- index of `foo`
-# Collection types
-Prefer `rustc_hash::FxHashMap` and `rustc_hash::FxHashSet` instead of the ones in `std::collections`.
-They use a hasher that's slightly faster and using them consistently will reduce code size by some small amount.
-# Preconditions
 Express function preconditions in types and force the caller to provide them (rather than checking in callee):
@@ -199,9 +111,15 @@ fn frobnicate(walrus: Option<Walrus>) {
 Avoid preconditions that span across function boundaries:
 ```rust
 // Good
+fn main() {
+    let s: &str = ...;
+    if let Some(contents) = string_literal_contents(s) {
+    }
+}
 fn string_literal_contents(s: &str) -> Option<&str> {
    if s.starts_with('"') && s.ends_with('"') {
        Some(&s[1..s.len() - 1])
@@ -210,54 +128,37 @@ fn string_literal_contents(s: &str) -> Option<&str> {
    }
 }
-fn foo() {
+// Not as good
+fn main() {
    let s: &str = ...;
-    if let Some(contents) = string_literal_contents(s) {
+    if is_string_literal(s) {
+        let contents = &s[1..s.len() - 1];
    }
 }
-// Not as good
 fn is_string_literal(s: &str) -> bool {
    s.starts_with('"') && s.ends_with('"')
 }
-fn foo() {
-    let s: &str = ...;
-    if is_string_literal(s) {
-        let contents = &s[1..s.len() - 1];
-    }
-}
 ```
 In the "Not as good" version, the precondition that `1` is a valid char boundary is checked in `is_string_literal` and used in `foo`.
 In the "Good" version, the precondition check and usage are checked in the same block, and then encoded in the types.
-# Early Returns
+When checking a boolean precondition, prefer `if !invariant` to `if negated_invariant`:
-Do use early returns
 ```rust
 // Good
-fn foo() -> Option<Bar> {
+if !(idx < len) {
-    if !condition() {
+    return None;
-        return None;
-    }
-    Some(...)
 }
 // Not as good
-fn foo() -> Option<Bar> {
+if idx >= len {
-    if condition() {
+    return None;
-        Some(...)
-    } else {
-        None
-    }
 }
 ```
-# Getters & Setters
+## Getters & Setters
 If a field can have any value without breaking invariants, make the field public.
 Conversely, if there is an invariant, document it, enforce it in the "constructor" function, make the field private, and provide a getter.
@@ -285,6 +186,40 @@ impl Person {
 }
 ```
+## Avoid Monomorphization
+Rust uses monomorphization to compile generic code, meaning that for each instantiation of a generic functions with concrete types, the function is compiled afresh, *per crate*.
+This allows for exceptionally good performance, but leads to increased compile times.
+Runtime performance obeys 80%/20% rule -- only a small fraction of code is hot.
+Compile time **does not** obey this rule -- all code has to be compiled.
+For this reason, avoid making a lot of code type parametric, *especially* on the boundaries between crates.
+```rust
+// Good
+fn frbonicate(f: impl FnMut()) {
+    frobnicate_impl(&mut f)
+}
+fn frobnicate_impl(f: &mut dyn FnMut()) {
+    // lots of code
+}
+// Not as good
+fn frbonicate(f: impl FnMut()) {
+    // lots of code
+}
+```
+Avoid `AsRef` polymorphism, it pays back only for widely used libraries:
+```rust
+// Good
+fn frbonicate(f: &Path) {
+}
+// Not as good
+fn frbonicate(f: impl AsRef<Path>) {
+}
+```
 # Premature Pessimization
@@ -322,62 +257,159 @@ fn frobnicate(s: &str) {
 }
 ```
-# Avoid Monomorphization
+## Collection types
-Rust uses monomorphization to compile generic code, meaning that for each instantiation of a generic functions with concrete types, the function is compiled afresh, *per crate*.
+Prefer `rustc_hash::FxHashMap` and `rustc_hash::FxHashSet` instead of the ones in `std::collections`.
-This allows for exceptionally good performance, but leads to increased compile times.
+They use a hasher that's slightly faster and using them consistently will reduce code size by some small amount.
-Runtime performance obeys 80%/20% rule -- only a small fraction of code is hot.
-Compile time **does not** obey this rule -- all code has to be compiled.
+# Style
-For this reason, avoid making a lot of code type parametric, *especially* on the boundaries between crates.
+## Order of Imports
+Separate import groups with blank lines.
+Use one `use` per crate.
+```rust
+mod x;
+mod y;
+// First std.
+use std::{ ... }
+// Second, external crates (both crates.io crates and other rust-analyzer crates).
+use crate_foo::{ ... }
+use crate_bar::{ ... }
+// Then current crate.
+use crate::{}
+// Finally, parent and child modules, but prefer `use crate::`.
+use super::{}
+```
+Module declarations come before the imports.
+Order them in "suggested reading order" for a person new to the code base.
+## Import Style
+Qualify items from `hir` and `ast`.
 ```rust
 // Good
-fn frbonicate(f: impl FnMut()) {
+use syntax::ast;
-    frobnicate_impl(&mut f)
-}
+fn frobnicate(func: hir::Function, strukt: ast::StructDef) {}
-fn frobnicate_impl(f: &mut dyn FnMut()) {
-    // lots of code
+// Not as good
+use hir::Function;
+use syntax::ast::StructDef;
+fn frobnicate(func: Function, strukt: StructDef) {}
+```
+Avoid local `use MyEnum::*` imports.
+Prefer `use crate::foo::bar` to `use super::bar`.
+When implementing `Debug` or `Display`, import `std::fmt`:
+```rust
+// Good
+use std::fmt;
+impl fmt::Display for RenameError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { .. }
 }
 // Not as good
-fn frbonicate(f: impl FnMut()) {
+impl std::fmt::Display for RenameError {
-    // lots of code
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { .. }
 }
 ```
-Avoid `AsRef` polymorphism, it pays back only for widely used libraries:
+## Order of Items
+Optimize for the reader who sees the file for the first time, and wants to get a general idea about what's going on.
+People read things from top to bottom, so place most important things first.
+Specifically, if all items except one are private, always put the non-private item on top.
+Put `struct`s and `enum`s first, functions and impls last.
+Do
 ```rust
 // Good
-fn frbonicate(f: &Path) {
+struct Foo {
+    bars: Vec<Bar>
 }
+struct Bar;
+```
+rather than
+```rust
 // Not as good
-fn frbonicate(f: impl AsRef<Path>) {
+struct Bar;
+struct Foo {
+    bars: Vec<Bar>
 }
 ```
-# Documentation
+## Variable Naming
-For `.md` and `.adoc` files, prefer a sentence-per-line format, don't wrap lines.
+Use boring and long names for local variables ([yay code completion](https://github.com/rust-analyzer/rust-analyzer/pull/4162#discussion_r417130973)).
-If the line is too long, you want to split the sentence in two :-)
+The default name is a lowercased name of the type: `global_state: GlobalState`.
+Avoid ad-hoc acronyms and contractions, but use the ones that exist consistently (`db`, `ctx`, `acc`).
-# Commit Style
+Default names:
-We don't have specific rules around git history hygiene.
+* `res` -- "result of the function" local variable
-Maintaining clean git history is strongly encouraged, but not enforced.
+* `it` -- I don't really care about the name
-Use rebase workflow, it's OK to rewrite history during PR review process.
+* `n_foo` -- number of foos
-After you are happy with the state of the code, please use [interactive rebase](https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History) to squash fixup commits.
+* `foo_idx` -- index of `foo`
-Avoid @mentioning people in commit messages and pull request descriptions(they are added to commit message by bors).
-Such messages create a lot of duplicate notification traffic during rebases.
-# Clippy
+## Early Returns
-We don't enforce Clippy.
+Do use early returns
-A number of default lints have high false positive rate.
-Selectively patching false-positives with `allow(clippy)` is considered worse than not using Clippy at all.
+```rust
-There's `cargo xtask lint` command which runs a subset of low-FPR lints.
+// Good
-Careful tweaking of `xtask lint` is welcome.
+fn foo() -> Option<Bar> {
-See also [rust-lang/clippy#5537](https://github.com/rust-lang/rust-clippy/issues/5537).
+    if !condition() {
-Of course, applying Clippy suggestions is welcome as long as they indeed improve the code.
+        return None;
+    }
+    Some(...)
+}
+// Not as good
+fn foo() -> Option<Bar> {
+    if condition() {
+        Some(...)
+    } else {
+        None
+    }
+}
+```
+## Comparisons
+Use `<`/`<=`, avoid `>`/`>=`.
+Less-then comparisons are more intuitive, they correspond spatially to [real line](https://en.wikipedia.org/wiki/Real_line)
+```rust
+// Good
+assert!(lo <= x && x <= hi);
+// Not as good
+assert!(x >= lo && x <= hi>);
+```
+## Documentation
+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 :-)
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index c1a778852..46e7bd091 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -397,6 +397,23 @@ It is possible to change the foreground/background color of inlay hints. Just ad
 }
 ----
+==== Semantic style customizations
+You can customize the look of different semantic elements in the source code. For example, mutable bindings are underlined by default and you can override this behavior by adding the following section to your `settings.json`:
+[source,jsonc]
+----
+{
+  "editor.semanticTokenColorCustomizations": {
+    "rules": {
+      "*.mutable": {
+        "fontStyle": "", // underline is the default
+      },
+    }
+  },
+}
+----
 ==== Special `when` clause context for keybindings.
 You may use `inRustProject` context to configure keybindings for rust projects only. For example:
 [source,json]
diff --git a/editors/code/package.json b/editors/code/package.json
index cc2ac3bd2..6a712a8a8 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -652,6 +652,21 @@
                    "default": "full",
                    "description": "The strategy to use when inserting new imports or merging imports."
                },
+                "rust-analyzer.assist.importPrefix": {
+                    "type": "string",
+                    "enum": [
+                        "plain",
+                        "by_self",
+                        "by_crate"
+                    ],
+                    "enumDescriptions": [
+                        "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item.",
+                        "Prefix all import paths with `self` if they don't begin with `self`, `super`, `crate` or a crate name",
+                        "Force import paths to be absolute by always starting them with `crate` or the crate name they refer to."
+                    ],
+                    "default": "plain",
+                    "description": "The path structure for newly inserted paths to use."
+                },
                "rust-analyzer.runnables.overrideCargo": {
                    "type": [
                        "null",
diff --git a/xtask/src/codegen/gen_feature_docs.rs b/xtask/src/codegen/gen_feature_docs.rs
index 3f0013e82..341e67c73 100644
--- a/xtask/src/codegen/gen_feature_docs.rs
+++ b/xtask/src/codegen/gen_feature_docs.rs
@@ -38,7 +38,9 @@ impl Feature {
            for block in comment_blocks {
                let id = block.id;
-                assert!(is_valid_feature_name(&id), "invalid feature name: {:?}", id);
+                if let Err(msg) = is_valid_feature_name(&id) {
+                    panic!("invalid feature name: {:?}:\n  {}", id, msg)
+                }
                let doc = block.contents.join("\n");
                let location = Location::new(path.clone(), block.line);
                acc.push(Feature { id, location, doc })
@@ -49,7 +51,7 @@ impl Feature {
    }
 }
-fn is_valid_feature_name(feature: &str) -> bool {
+fn is_valid_feature_name(feature: &str) -> Result<(), String> {
    'word: for word in feature.split_whitespace() {
        for &short in ["to", "and"].iter() {
            if word == short {
@@ -58,14 +60,14 @@ fn is_valid_feature_name(feature: &str) -> bool {
        }
        for &short in ["To", "And"].iter() {
            if word == short {
-                return false;
+                return Err(format!("Don't capitalize {:?}", word));
            }
        }
        if !word.starts_with(char::is_uppercase) {
-            return false;
+            return Err(format!("Capitalize {:?}", word));
        }
    }
-    true
+    Ok(())
 }
 impl fmt::Display for Feature {
diff --git a/xtask/tests/tidy.rs b/xtask/tests/tidy.rs
index 02b3afc96..01f04a17c 100644
--- a/xtask/tests/tidy.rs
+++ b/xtask/tests/tidy.rs
@@ -38,6 +38,13 @@ fn check_code_formatting() {
 }
 #[test]
+fn smoke_test_docs_generation() {
+    // We don't commit docs to the repo, so we can just overwrite in tests.
+    codegen::generate_assists_docs(Mode::Overwrite).unwrap();
+    codegen::generate_feature_docs(Mode::Overwrite).unwrap();
+}
+#[test]
 fn rust_files_are_tidy() {
    let mut tidy_docs = TidyDocs::default();
    for path in rust_files(&project_root().join("crates")) {