51 files changed, 2083 insertions, 310 deletions
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);
+}