8 files changed, 225 insertions, 150 deletions

diff --git a/crates/hir_def/src/nameres/tests/mod_resolution.rs b/crates/hir_def/src/nameres/tests/mod_resolution.rs
index ba295fd9e..ef6f85e15 100644
--- a/crates/hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/tests/mod_resolution.rs
@@ -798,3 +798,24 @@ mod foo;
 "#,
     );
 }
+
+#[test]
+fn abs_path_ignores_local() {
+    check(
+        r#"
+//- /main.rs crate:main deps:core
+pub use ::core::hash::Hash;
+pub mod core {}
+
+//- /lib.rs crate:core
+pub mod hash { pub trait Hash {} }
+"#,
+        expect![[r#"
+            crate
+            Hash: t
+            core: t
+
+            crate::core
+        "#]],
+    );
+}
diff --git a/crates/hir_def/src/path/lower/lower_use.rs b/crates/hir_def/src/path/lower/lower_use.rs
index 53cecb05f..ba0d1f0e7 100644
--- a/crates/hir_def/src/path/lower/lower_use.rs
+++ b/crates/hir_def/src/path/lower/lower_use.rs
@@ -76,7 +76,7 @@ fn convert_path(prefix: Option<ModPath>, path: ast::Path, hygiene: &Hygiene) ->
                 Either::Left(name) => {
                     // no type args in use
                     let mut res = prefix.unwrap_or_else(|| ModPath {
-                        kind: PathKind::Plain,
+                        kind: segment.coloncolon_token().map_or(PathKind::Plain, |_| PathKind::Abs),
                         segments: Vec::with_capacity(1),
                     });
                     res.segments.push(name);
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 94ad800a0..462f5c2b8 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -295,7 +295,6 @@ fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String>
             ModuleDef::EnumVariant(e) => Some(e.parent_enum(db).name(db)),
             _ => None,
         },
-        Definition::SelfType(i) => i.target_ty(db).as_adt().map(|adt| adt.name(db)),
         _ => None,
     }
     .map(|name| name.to_string())
@@ -357,7 +356,14 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
             ModuleDef::BuiltinType(it) => return Some(it.to_string().into()),
         },
         Definition::Local(it) => return Some(Markup::fenced_block(&it.ty(db).display(db))),
-        Definition::TypeParam(_) | Definition::SelfType(_) => {
+        Definition::SelfType(impl_def) => {
+            impl_def.target_ty(db).as_adt().and_then(|adt| match adt {
+                Adt::Struct(it) => from_def_source(db, it, mod_path),
+                Adt::Union(it) => from_def_source(db, it, mod_path),
+                Adt::Enum(it) => from_def_source(db, it, mod_path),
+            })
+        }
+        Definition::TypeParam(_) => {
             // FIXME: Hover for generic param
             None
         }
@@ -1025,52 +1031,75 @@ impl Thing {
 }
 "#,
             expect![[r#"
-                *Self { x: 0 }*
+                *Self*
+
                 ```rust
-                Thing
+                test
+                ```
+
+                ```rust
+                struct Thing
                 ```
             "#]],
-        )
-    } /* FIXME: revive these tests
-              let (analysis, position) = fixture::position(
-                  "
-                  struct Thing { x: u32 }
-                  impl Thing {
-                      fn new() -> Self<|> {
-                          Self { x: 0 }
-                      }
-                  }
-                  ",
-              );
-
-              let hover = analysis.hover(position).unwrap().unwrap();
-              assert_eq!(trim_markup(&hover.info.markup.as_str()), ("Thing"));
-
-              let (analysis, position) = fixture::position(
-                  "
-                  enum Thing { A }
-                  impl Thing {
-                      pub fn new() -> Self<|> {
-                          Thing::A
-                      }
-                  }
-                  ",
-              );
-              let hover = analysis.hover(position).unwrap().unwrap();
-              assert_eq!(trim_markup(&hover.info.markup.as_str()), ("enum Thing"));
-
-              let (analysis, position) = fixture::position(
-                  "
-                  enum Thing { A }
-                  impl Thing {
-                      pub fn thing(a: Self<|>) {
-                      }
-                  }
-                  ",
-              );
-              let hover = analysis.hover(position).unwrap().unwrap();
-              assert_eq!(trim_markup(&hover.info.markup.as_str()), ("enum Thing"));
-      */
+        );
+        check(
+            r#"
+struct Thing { x: u32 }
+impl Thing {
+    fn new() -> Self<|> { Self { x: 0 } }
+}
+"#,
+            expect![[r#"
+                *Self*
+
+                ```rust
+                test
+                ```
+
+                ```rust
+                struct Thing
+                ```
+            "#]],
+        );
+        check(
+            r#"
+enum Thing { A }
+impl Thing {
+    pub fn new() -> Self<|> { Thing::A }
+}
+"#,
+            expect![[r#"
+                *Self*
+
+                ```rust
+                test
+                ```
+
+                ```rust
+                enum Thing
+                ```
+            "#]],
+        );
+        check(
+            r#"
+        enum Thing { A }
+        impl Thing {
+            pub fn thing(a: Self<|>) {}
+        }
+        "#,
+            expect![[r#"
+                *Self*
+
+                ```rust
+                test
+                ```
+
+                ```rust
+                enum Thing
+                ```
+            "#]],
+        );
+    }
 
     #[test]
     fn test_hover_shadowing_pat() {
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index b985861f2..fa40e64e8 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -543,11 +543,6 @@ impl HasFormatSpecifier for ast::String {
 }
 
 impl ast::IntNumber {
-    const SUFFIXES: &'static [&'static str] = &[
-        "u8", "u16", "u32", "u64", "u128", "usize", // Unsigned.
-        "i8", "i16", "i32", "i64", "i128", "isize", // Signed.
-    ];
-
     pub fn radix(&self) -> Radix {
         match self.text().get(..2).unwrap_or_default() {
             "0b" => Radix::Binary,
@@ -580,29 +575,30 @@ impl ast::IntNumber {
 
     pub fn suffix(&self) -> Option<&str> {
         let text = self.text();
-        // FIXME: don't check a fixed set of suffixes, `1_0_1_l_o_l` is valid
-        // syntax, suffix is `l_o_l`.
-        ast::IntNumber::SUFFIXES.iter().chain(ast::FloatNumber::SUFFIXES.iter()).find_map(
-            |suffix| {
-                if text.ends_with(suffix) {
-                    return Some(&text[text.len() - suffix.len()..]);
-                }
-                None
-            },
-        )
+        let radix = self.radix();
+        let mut indices = text.char_indices();
+        if radix != Radix::Decimal {
+            indices.next()?;
+            indices.next()?;
+        }
+        let is_suffix_start: fn(&(usize, char)) -> bool = match radix {
+            Radix::Hexadecimal => |(_, c)| matches!(c, 'g'..='z' | 'G'..='Z'),
+            _ => |(_, c)| c.is_ascii_alphabetic(),
+        };
+        let (suffix_start, _) = indices.find(is_suffix_start)?;
+        Some(&text[suffix_start..])
     }
 }
 
 impl ast::FloatNumber {
-    const SUFFIXES: &'static [&'static str] = &["f32", "f64"];
     pub fn suffix(&self) -> Option<&str> {
         let text = self.text();
-        ast::FloatNumber::SUFFIXES.iter().find_map(|suffix| {
-            if text.ends_with(suffix) {
-                return Some(&text[text.len() - suffix.len()..]);
-            }
-            None
-        })
+        let mut indices = text.char_indices();
+        let (mut suffix_start, c) = indices.by_ref().find(|(_, c)| c.is_ascii_alphabetic())?;
+        if c == 'e' || c == 'E' {
+            suffix_start = indices.find(|(_, c)| c.is_ascii_alphabetic())?.0;
+        }
+        Some(&text[suffix_start..])
     }
 }
 
@@ -625,3 +621,40 @@ impl Radix {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::ast::{make, FloatNumber, IntNumber};
+
+    fn check_float_suffix<'a>(lit: &str, expected: impl Into<Option<&'a str>>) {
+        assert_eq!(FloatNumber { syntax: make::tokens::literal(lit) }.suffix(), expected.into());
+    }
+
+    fn check_int_suffix<'a>(lit: &str, expected: impl Into<Option<&'a str>>) {
+        assert_eq!(IntNumber { syntax: make::tokens::literal(lit) }.suffix(), expected.into());
+    }
+
+    #[test]
+    fn test_float_number_suffix() {
+        check_float_suffix("123.0", None);
+        check_float_suffix("123f32", "f32");
+        check_float_suffix("123.0e", None);
+        check_float_suffix("123.0e4", None);
+        check_float_suffix("123.0ef32", "f32");
+        check_float_suffix("123.0E4f32", "f32");
+        check_float_suffix("1_2_3.0_f32", "f32");
+    }
+
+    #[test]
+    fn test_int_number_suffix() {
+        check_int_suffix("123", None);
+        check_int_suffix("123i32", "i32");
+        check_int_suffix("1_0_1_l_o_l", "l_o_l");
+        check_int_suffix("0b11", None);
+        check_int_suffix("0o11", None);
+        check_int_suffix("0xff", None);
+        check_int_suffix("0b11u32", "u32");
+        check_int_suffix("0o11u32", "u32");
+        check_int_suffix("0xffu32", "u32");
+    }
+}
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
index 4aa2d6526..9093fbd97 100644
--- a/crates/vfs/src/file_set.rs
+++ b/crates/vfs/src/file_set.rs
@@ -158,53 +158,4 @@ impl fst::Automaton for PrefixOf<'_> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn path_prefix() {
-        let mut file_set = FileSetConfig::builder();
-        file_set.add_file_set(vec![VfsPath::new_virtual_path("/foo".into())]);
-        file_set.add_file_set(vec![VfsPath::new_virtual_path("/foo/bar/baz".into())]);
-        let file_set = file_set.build();
-
-        let mut vfs = Vfs::default();
-        vfs.set_file_contents(
-            VfsPath::new_virtual_path("/foo/src/lib.rs".into()),
-            Some(Vec::new()),
-        );
-        vfs.set_file_contents(
-            VfsPath::new_virtual_path("/foo/src/bar/baz/lib.rs".into()),
-            Some(Vec::new()),
-        );
-        vfs.set_file_contents(
-            VfsPath::new_virtual_path("/foo/bar/baz/lib.rs".into()),
-            Some(Vec::new()),
-        );
-        vfs.set_file_contents(VfsPath::new_virtual_path("/quux/lib.rs".into()), Some(Vec::new()));
-
-        let partition = file_set.partition(&vfs).into_iter().map(|it| it.len()).collect::<Vec<_>>();
-        assert_eq!(partition, vec![2, 1, 1]);
-    }
-
-    #[test]
-    fn name_prefix() {
-        let mut file_set = FileSetConfig::builder();
-        file_set.add_file_set(vec![VfsPath::new_virtual_path("/foo".into())]);
-        file_set.add_file_set(vec![VfsPath::new_virtual_path("/foo-things".into())]);
-        let file_set = file_set.build();
-
-        let mut vfs = Vfs::default();
-        vfs.set_file_contents(
-            VfsPath::new_virtual_path("/foo/src/lib.rs".into()),
-            Some(Vec::new()),
-        );
-        vfs.set_file_contents(
-            VfsPath::new_virtual_path("/foo-things/src/lib.rs".into()),
-            Some(Vec::new()),
-        );
-
-        let partition = file_set.partition(&vfs).into_iter().map(|it| it.len()).collect::<Vec<_>>();
-        assert_eq!(partition, vec![1, 1, 0]);
-    }
-}
+mod tests;
diff --git a/crates/vfs/src/file_set/tests.rs b/crates/vfs/src/file_set/tests.rs
new file mode 100644
index 000000000..2146df185
--- /dev/null
+++ b/crates/vfs/src/file_set/tests.rs
@@ -0,0 +1,42 @@
+use super::*;
+
+#[test]
+fn path_prefix() {
+    let mut file_set = FileSetConfig::builder();
+    file_set.add_file_set(vec![VfsPath::new_virtual_path("/foo".into())]);
+    file_set.add_file_set(vec![VfsPath::new_virtual_path("/foo/bar/baz".into())]);
+    let file_set = file_set.build();
+
+    let mut vfs = Vfs::default();
+    vfs.set_file_contents(VfsPath::new_virtual_path("/foo/src/lib.rs".into()), Some(Vec::new()));
+    vfs.set_file_contents(
+        VfsPath::new_virtual_path("/foo/src/bar/baz/lib.rs".into()),
+        Some(Vec::new()),
+    );
+    vfs.set_file_contents(
+        VfsPath::new_virtual_path("/foo/bar/baz/lib.rs".into()),
+        Some(Vec::new()),
+    );
+    vfs.set_file_contents(VfsPath::new_virtual_path("/quux/lib.rs".into()), Some(Vec::new()));
+
+    let partition = file_set.partition(&vfs).into_iter().map(|it| it.len()).collect::<Vec<_>>();
+    assert_eq!(partition, vec![2, 1, 1]);
+}
+
+#[test]
+fn name_prefix() {
+    let mut file_set = FileSetConfig::builder();
+    file_set.add_file_set(vec![VfsPath::new_virtual_path("/foo".into())]);
+    file_set.add_file_set(vec![VfsPath::new_virtual_path("/foo-things".into())]);
+    let file_set = file_set.build();
+
+    let mut vfs = Vfs::default();
+    vfs.set_file_contents(VfsPath::new_virtual_path("/foo/src/lib.rs".into()), Some(Vec::new()));
+    vfs.set_file_contents(
+        VfsPath::new_virtual_path("/foo-things/src/lib.rs".into()),
+        Some(Vec::new()),
+    );
+
+    let partition = file_set.partition(&vfs).into_iter().map(|it| it.len()).collect::<Vec<_>>();
+    assert_eq!(partition, vec![1, 1, 0]);
+}
diff --git a/crates/vfs/src/vfs_path.rs b/crates/vfs/src/vfs_path.rs
index 815697597..bd14911c9 100644
--- a/crates/vfs/src/vfs_path.rs
+++ b/crates/vfs/src/vfs_path.rs
@@ -311,35 +311,4 @@ impl VirtualPath {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn virtual_path_extensions() {
-        assert_eq!(VirtualPath("/".to_string()).name_and_extension(), None);
-        assert_eq!(
-            VirtualPath("/directory".to_string()).name_and_extension(),
-            Some(("directory", None))
-        );
-        assert_eq!(
-            VirtualPath("/directory/".to_string()).name_and_extension(),
-            Some(("directory", None))
-        );
-        assert_eq!(
-            VirtualPath("/directory/file".to_string()).name_and_extension(),
-            Some(("file", None))
-        );
-        assert_eq!(
-            VirtualPath("/directory/.file".to_string()).name_and_extension(),
-            Some((".file", None))
-        );
-        assert_eq!(
-            VirtualPath("/directory/.file.rs".to_string()).name_and_extension(),
-            Some((".file", Some("rs")))
-        );
-        assert_eq!(
-            VirtualPath("/directory/file.rs".to_string()).name_and_extension(),
-            Some(("file", Some("rs")))
-        );
-    }
-}
+mod tests;
diff --git a/crates/vfs/src/vfs_path/tests.rs b/crates/vfs/src/vfs_path/tests.rs
new file mode 100644
index 000000000..510e021e8
--- /dev/null
+++ b/crates/vfs/src/vfs_path/tests.rs
@@ -0,0 +1,30 @@
+use super::*;
+
+#[test]
+fn virtual_path_extensions() {
+    assert_eq!(VirtualPath("/".to_string()).name_and_extension(), None);
+    assert_eq!(
+        VirtualPath("/directory".to_string()).name_and_extension(),
+        Some(("directory", None))
+    );
+    assert_eq!(
+        VirtualPath("/directory/".to_string()).name_and_extension(),
+        Some(("directory", None))
+    );
+    assert_eq!(
+        VirtualPath("/directory/file".to_string()).name_and_extension(),
+        Some(("file", None))
+    );
+    assert_eq!(
+        VirtualPath("/directory/.file".to_string()).name_and_extension(),
+        Some((".file", None))
+    );
+    assert_eq!(
+        VirtualPath("/directory/.file.rs".to_string()).name_and_extension(),
+        Some((".file", Some("rs")))
+    );
+    assert_eq!(
+        VirtualPath("/directory/file.rs".to_string()).name_and_extension(),
+        Some(("file", Some("rs")))
+    );
+}