208 files changed, 14085 insertions, 8738 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 08e9c10d8..bed9acf8f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,9 +2,9 @@
 # It is not intended for manual editing.
 [[package]]
 name = "addr2line"
-version = "0.12.1"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a49806b9dadc843c61e7c97e72490ad7f7220ae249012fbda9ad0609457c0543"
+checksum = "602d785912f476e480434627e8732e6766b760c045bbf897d9dfaa9f4fbd399c"
 dependencies = [
  "gimli",
 ]
@@ -288,9 +288,9 @@ checksum = "69b26e475fd29098530e709294e94e661974c851aed42512793f120fed4e199f"
 
 [[package]]
 name = "dtoa"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4358a9e11b9a09cf52383b451b49a169e8d797b68aa02301ff586d70d9661ea3"
+checksum = "134951f4028bdadb9b84baf4232681efbf277da25144b9b0ad65df75946c422b"
 
 [[package]]
 name = "either"
@@ -354,9 +354,9 @@ checksum = "5f2a4a2034423744d2cc7ca2068453168dcdb82c438419e639a26bd87839c674"
 
 [[package]]
 name = "fsevent"
-version = "0.4.0"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ab7d1bd1bd33cc98b0889831b72da23c0aa4df9cec7e0702f46ecea04b35db6"
+checksum = "97f347202c95c98805c216f9e1df210e8ebaec9fdb2365700a43c10797a35e63"
 dependencies = [
  "bitflags",
  "fsevent-sys",
@@ -364,9 +364,9 @@ dependencies = [
 
 [[package]]
 name = "fsevent-sys"
-version = "2.0.1"
+version = "3.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f41b048a94555da0f42f1d632e2e19510084fb8e303b0daa2816e733fb3644a0"
+checksum = "77a29c77f1ca394c3e73a9a5d24cfcabb734682d9634fc398f2204a63c994120"
 dependencies = [
  "libc",
 ]
@@ -483,9 +483,9 @@ dependencies = [
 
 [[package]]
 name = "inotify"
-version = "0.7.1"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4816c66d2c8ae673df83366c18341538f234a26d65a9ecea5c348b453ac1d02f"
+checksum = "46dd0a94b393c730779ccfd2a872b67b1eb67be3fc33082e733bdb38b5fde4d4"
 dependencies = [
  "bitflags",
  "inotify-sys",
@@ -535,9 +535,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8b7a7c0c47db5545ed3fef7468ee7bb5b74691498139e4b3f6a20685dc6dd8e"
+checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
 
 [[package]]
 name = "jemalloc-ctl"
@@ -640,9 +640,9 @@ dependencies = [
 
 [[package]]
 name = "lsp-server"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dccec31bfd027ac0dd288a78e19005fd89624d9099456e284b5241316a6c3072"
+checksum = "53b4ace8ebe5d2aff3687ce0ed507f6020d6a47a7de2b0d3d664ea237ffb0c62"
 dependencies = [
  "crossbeam-channel",
  "log",
@@ -766,11 +766,13 @@ dependencies = [
 
 [[package]]
 name = "notify"
-version = "4.0.15"
+version = "5.0.0-pre.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80ae4a7688d1fab81c5bf19c64fc8db920be8d519ce6336ed4e7efe024724dbd"
+checksum = "77d03607cf88b4b160ba0e9ed425fff3cee3b55ac813f0c685b3a3772da37d0e"
 dependencies = [
+ "anymap",
  "bitflags",
+ "crossbeam-channel",
  "filetime",
  "fsevent",
  "fsevent-sys",
@@ -830,9 +832,9 @@ dependencies = [
 
 [[package]]
 name = "paste"
-version = "0.1.17"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "026c63fe245362be0322bfec5a9656d458d13f9cfb1785d1b38458b9968e8080"
+checksum = "45ca20c77d80be666aef2b45486da86238fabe33e38306bd3118fe4af33fa880"
 dependencies = [
  "paste-impl",
  "proc-macro-hack",
@@ -840,9 +842,9 @@ dependencies = [
 
 [[package]]
 name = "paste-impl"
-version = "0.1.17"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b9281a268ec213237dcd2aa3c3d0f46681b04ced37c1616fd36567a9e6954b0"
+checksum = "d95a7db200b97ef370c8e6de0088252f7e0dfff7d047a28528e47456c0fc98b6"
 dependencies = [
  "proc-macro-hack",
 ]
@@ -952,7 +954,9 @@ dependencies = [
  "relative-path",
  "rustc-hash",
  "salsa",
+ "stdx",
  "test_utils",
+ "vfs",
 ]
 
 [[package]]
@@ -1015,6 +1019,7 @@ dependencies = [
  "ra_syntax",
  "ra_tt",
  "rustc-hash",
+ "smallvec",
  "stdx",
  "test_utils",
 ]
@@ -1076,7 +1081,11 @@ dependencies = [
  "ra_hir",
  "ra_ide_db",
  "ra_prof",
+<<<<<<< HEAD
+ "ra_ssr",
+=======
  "ra_progress",
+>>>>>>> Veetaha-feat/sync-branch
  "ra_syntax",
  "ra_text_edit",
  "rand",
@@ -1178,6 +1187,7 @@ dependencies = [
  "anyhow",
  "cargo_metadata",
  "log",
+ "paths",
  "ra_arena",
  "ra_cfg",
  "ra_db",
@@ -1186,6 +1196,19 @@ dependencies = [
  "rustc-hash",
  "serde",
  "serde_json",
+ "stdx",
+]
+
+[[package]]
+name = "ra_ssr"
+version = "0.1.0"
+dependencies = [
+ "ra_db",
+ "ra_hir",
+ "ra_ide_db",
+ "ra_syntax",
+ "ra_text_edit",
+ "rustc-hash",
 ]
 
 [[package]]
@@ -1229,22 +1252,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "ra_vfs"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbf31a173fc77ec59c27cf39af6baa137b40f4dbd45a8b3eccb1b2e4cfc922c1"
-dependencies = [
- "crossbeam-channel",
- "jod-thread",
- "log",
- "notify",
- "parking_lot",
- "relative-path",
- "rustc-hash",
- "walkdir",
-]
-
-[[package]]
 name = "rand"
 version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1402,9 +1409,7 @@ dependencies = [
  "ra_syntax",
  "ra_text_edit",
  "ra_tt",
- "ra_vfs",
  "rand",
- "relative-path",
  "rustc-hash",
  "serde",
  "serde_json",
@@ -1412,6 +1417,8 @@ dependencies = [
  "tempfile",
  "test_utils",
  "threadpool",
+ "vfs",
+ "vfs-notify",
  "winapi 0.3.8",
 ]
 
@@ -1529,18 +1536,18 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
 [[package]]
 name = "serde"
-version = "1.0.112"
+version = "1.0.113"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "736aac72d1eafe8e5962d1d1c3d99b0df526015ba40915cb3c49d042e92ec243"
+checksum = "6135c78461981c79497158ef777264c51d9d0f4f3fc3a4d22b915900e42dac6a"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.112"
+version = "1.0.113"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf0343ce212ac0d3d6afd9391ac8e9c9efe06b533c8d33f660f6390cc4093f57"
+checksum = "93c5eaa17d0954cb481cdcfffe9d84fcfa7a1a9f2349271e678677be4c26ae31"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1560,9 +1567,9 @@ dependencies = [
 
 [[package]]
 name = "serde_repr"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd02c7587ec314570041b2754829f84d873ced14a96d1fd1823531e11db40573"
+checksum = "2dc6b7951b17b051f3210b063f12cc17320e2fe30ae05b0fe2a3abb068551c76"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1614,9 +1621,9 @@ checksum = "ab16ced94dbd8a46c82fd81e3ed9a8727dac2977ea869d217bcc4ea1f122e81f"
 
 [[package]]
 name = "syn"
-version = "1.0.31"
+version = "1.0.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5304cfdf27365b7585c25d4af91b35016ed21ef88f17ced89c7093b43dba8b6"
+checksum = "a994520748611c17d163e81b6c4a4b13d11b7f63884362ab2efac3aa9cf16d00"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1673,8 +1680,6 @@ name = "test_utils"
 version = "0.1.0"
 dependencies = [
  "difference",
- "ra_cfg",
- "relative-path",
  "rustc-hash",
  "serde_json",
  "stdx",
@@ -1712,6 +1717,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "tinyvec"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53953d2d3a5ad81d9f844a32f14ebb121f50b650cd59d0ee2a07cf13c617efed"
+
+[[package]]
 name = "unicode-bidi"
 version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1722,11 +1733,11 @@ dependencies = [
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.12"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5479532badd04e128284890390c1e876ef7a993d0570b3597ae43dfa1d59afa4"
+checksum = "6fb19cf769fa8c6a80a162df694621ebeb4dafb606470b2b2fce0be40a98a977"
 dependencies = [
- "smallvec",
+ "tinyvec",
 ]
 
 [[package]]
@@ -1757,11 +1768,22 @@ dependencies = [
 name = "vfs"
 version = "0.1.0"
 dependencies = [
+ "paths",
+ "rustc-hash",
+]
+
+[[package]]
+name = "vfs-notify"
+version = "0.1.0"
+dependencies = [
  "crossbeam-channel",
  "globset",
  "jod-thread",
+ "log",
+ "notify",
  "paths",
  "rustc-hash",
+ "vfs",
  "walkdir",
 ]
 
diff --git a/crates/paths/src/lib.rs b/crates/paths/src/lib.rs
index c7ce0c42f..1b259682d 100644
--- a/crates/paths/src/lib.rs
+++ b/crates/paths/src/lib.rs
@@ -28,6 +28,12 @@ impl AsRef<Path> for AbsPathBuf {
     }
 }
 
+impl AsRef<AbsPath> for AbsPathBuf {
+    fn as_ref(&self) -> &AbsPath {
+        self.as_path()
+    }
+}
+
 impl TryFrom<PathBuf> for AbsPathBuf {
     type Error = PathBuf;
     fn try_from(path_buf: PathBuf) -> Result<AbsPathBuf, PathBuf> {
@@ -45,9 +51,19 @@ impl TryFrom<&str> for AbsPathBuf {
     }
 }
 
+impl PartialEq<AbsPath> for AbsPathBuf {
+    fn eq(&self, other: &AbsPath) -> bool {
+        self.as_path() == other
+    }
+}
+
 impl AbsPathBuf {
+    pub fn assert(path: PathBuf) -> AbsPathBuf {
+        AbsPathBuf::try_from(path)
+            .unwrap_or_else(|path| panic!("expected absolute path, got {}", path.display()))
+    }
     pub fn as_path(&self) -> &AbsPath {
-        AbsPath::new_unchecked(self.0.as_path())
+        AbsPath::assert(self.0.as_path())
     }
     pub fn pop(&mut self) -> bool {
         self.0.pop()
@@ -77,21 +93,99 @@ impl<'a> TryFrom<&'a Path> for &'a AbsPath {
         if !path.is_absolute() {
             return Err(path);
         }
-        Ok(AbsPath::new_unchecked(path))
+        Ok(AbsPath::assert(path))
     }
 }
 
 impl AbsPath {
-    fn new_unchecked(path: &Path) -> &AbsPath {
+    pub fn assert(path: &Path) -> &AbsPath {
+        assert!(path.is_absolute());
         unsafe { &*(path as *const Path as *const AbsPath) }
     }
 
+    pub fn parent(&self) -> Option<&AbsPath> {
+        self.0.parent().map(AbsPath::assert)
+    }
     pub fn join(&self, path: impl AsRef<Path>) -> AbsPathBuf {
         self.as_ref().join(path).try_into().unwrap()
     }
     pub fn normalize(&self) -> AbsPathBuf {
         AbsPathBuf(normalize_path(&self.0))
     }
+    pub fn to_path_buf(&self) -> AbsPathBuf {
+        AbsPathBuf::try_from(self.0.to_path_buf()).unwrap()
+    }
+    pub fn strip_prefix(&self, base: &AbsPath) -> Option<&RelPath> {
+        self.0.strip_prefix(base).ok().map(RelPath::new_unchecked)
+    }
+}
+
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct RelPathBuf(PathBuf);
+
+impl From<RelPathBuf> for PathBuf {
+    fn from(RelPathBuf(path_buf): RelPathBuf) -> PathBuf {
+        path_buf
+    }
+}
+
+impl ops::Deref for RelPathBuf {
+    type Target = RelPath;
+    fn deref(&self) -> &RelPath {
+        self.as_path()
+    }
+}
+
+impl AsRef<Path> for RelPathBuf {
+    fn as_ref(&self) -> &Path {
+        self.0.as_path()
+    }
+}
+
+impl TryFrom<PathBuf> for RelPathBuf {
+    type Error = PathBuf;
+    fn try_from(path_buf: PathBuf) -> Result<RelPathBuf, PathBuf> {
+        if !path_buf.is_relative() {
+            return Err(path_buf);
+        }
+        Ok(RelPathBuf(path_buf))
+    }
+}
+
+impl TryFrom<&str> for RelPathBuf {
+    type Error = PathBuf;
+    fn try_from(path: &str) -> Result<RelPathBuf, PathBuf> {
+        RelPathBuf::try_from(PathBuf::from(path))
+    }
+}
+
+impl RelPathBuf {
+    pub fn as_path(&self) -> &RelPath {
+        RelPath::new_unchecked(self.0.as_path())
+    }
+}
+
+#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
+#[repr(transparent)]
+pub struct RelPath(Path);
+
+impl ops::Deref for RelPath {
+    type Target = Path;
+    fn deref(&self) -> &Path {
+        &self.0
+    }
+}
+
+impl AsRef<Path> for RelPath {
+    fn as_ref(&self) -> &Path {
+        &self.0
+    }
+}
+
+impl RelPath {
+    pub fn new_unchecked(path: &Path) -> &RelPath {
+        unsafe { &*(path as *const Path as *const RelPath) }
+    }
 }
 
 // https://github.com/rust-lang/cargo/blob/79c769c3d7b4c2cf6a93781575b7f592ef974255/src/cargo/util/paths.rs#L60-L85
diff --git a/crates/ra_arena/src/lib.rs b/crates/ra_arena/src/lib.rs
index 441fbb3cb..3169aa5b8 100644
--- a/crates/ra_arena/src/lib.rs
+++ b/crates/ra_arena/src/lib.rs
@@ -116,6 +116,9 @@ impl<T> Arena<T> {
     ) -> impl Iterator<Item = (Idx<T>, &T)> + ExactSizeIterator + DoubleEndedIterator {
         self.data.iter().enumerate().map(|(idx, value)| (Idx::from_raw(RawId(idx as u32)), value))
     }
+    pub fn shrink_to_fit(&mut self) {
+        self.data.shrink_to_fit();
+    }
 }
 
 impl<T> Default for Arena<T> {
diff --git a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
index 776bddf91..b0e56e1b5 100644
--- a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
+++ b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
@@ -128,7 +128,7 @@ impl From<foo::bar::baz::Boo> for A {
 
     fn check_not_applicable(ra_fixture: &str) {
         let fixture =
-            format!("//- main.rs crate:main deps:core\n{}\n{}", ra_fixture, FamousDefs::FIXTURE);
+            format!("//- /main.rs crate:main deps:core\n{}\n{}", ra_fixture, FamousDefs::FIXTURE);
         check_assist_not_applicable(add_from_impl_for_enum, &fixture)
     }
 
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index 5092bf336..d1cafa7d9 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -488,16 +488,17 @@ mod tests {
         check_assist(
             auto_import,
             r"
-                    //- /lib.rs crate:crate_with_macro
-                    #[macro_export]
-                    macro_rules! foo {
-                        () => ()
-                    }
+//- /lib.rs crate:crate_with_macro
+#[macro_export]
+macro_rules! foo {
+    () => ()
+}
 
-                    //- /main.rs crate:main deps:crate_with_macro
-                    fn main() {
-                        foo<|>
-                    }",
+//- /main.rs crate:main deps:crate_with_macro
+fn main() {
+    foo<|>
+}
+",
             r"use crate_with_macro::foo;
 
 fn main() {
@@ -847,13 +848,14 @@ fn main() {
         check_assist(
             auto_import,
             r"
-                    //- /lib.rs crate:dep
-                    pub struct Struct;
+//- /lib.rs crate:dep
+pub struct Struct;
 
-                    //- /main.rs crate:main deps:dep
-                    fn main() {
-                        Struct<|>
-                    }",
+//- /main.rs crate:main deps:dep
+fn main() {
+    Struct<|>
+}
+",
             r"use dep::Struct;
 
 fn main() {
@@ -869,20 +871,22 @@ fn main() {
         check_assist(
             auto_import,
             r"
-                    //- /lib.rs crate:dep
-                    pub mod fmt {
-                        pub trait Display {}
-                    }
+//- /lib.rs crate:dep
+pub mod fmt {
+    pub trait Display {}
+}
 
-                    pub fn panic_fmt() {}
+pub fn panic_fmt() {}
 
-                    //- /main.rs crate:main deps:dep
-                    struct S;
+//- /main.rs crate:main deps:dep
+struct S;
 
-                    impl f<|>mt::Display for S {}",
+impl f<|>mt::Display for S {}
+",
             r"use dep::fmt;
 
 struct S;
+
 impl fmt::Display for S {}
 ",
         );
@@ -894,21 +898,20 @@ impl fmt::Display for S {}
         check_assist(
             auto_import,
             r"
-                    //- /lib.rs crate:dep
-
-                    macro_rules! mac {
-                        () => {
-                            pub struct Cheese;
-                        };
-                    }
-
-                    mac!();
+//- /lib.rs crate:dep
+macro_rules! mac {
+    () => {
+        pub struct Cheese;
+    };
+}
 
-                    //- /main.rs crate:main deps:dep
+mac!();
 
-                    fn main() {
-                        Cheese<|>;
-                    }",
+//- /main.rs crate:main deps:dep
+fn main() {
+    Cheese<|>;
+}
+",
             r"use dep::Cheese;
 
 fn main() {
@@ -924,16 +927,15 @@ fn main() {
         check_assist(
             auto_import,
             r"
-                    //- /lib.rs crate:dep
-
-                    pub struct FMT;
-                    pub struct fmt;
-
-                    //- /main.rs crate:main deps:dep
+//- /lib.rs crate:dep
+pub struct FMT;
+pub struct fmt;
 
-                    fn main() {
-                        FMT<|>;
-                    }",
+//- /main.rs crate:main deps:dep
+fn main() {
+    FMT<|>;
+}
+",
             r"use dep::FMT;
 
 fn main() {
diff --git a/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
index 44db7917a..43b4584b4 100644
--- a/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -301,7 +301,7 @@ fn another_fn() {
 
     fn check_not_applicable(ra_fixture: &str) {
         let fixture =
-            format!("//- main.rs crate:main deps:core\n{}\n{}", ra_fixture, FamousDefs::FIXTURE);
+            format!("//- /main.rs crate:main deps:core\n{}\n{}", ra_fixture, FamousDefs::FIXTURE);
         check_assist_not_applicable(extract_struct_from_enum_variant, &fixture)
     }
 
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 569efb768..64270c86f 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -763,9 +763,9 @@ mod tests {
 fn foo(opt: Option<i32>) {
     match opt<|> {
     }
-}"#;
-        let before =
-            &format!("//- main.rs crate:main deps:core\n{}{}", before, FamousDefs::FIXTURE);
+}
+"#;
+        let before = &format!("//- /main.rs crate:main deps:core{}{}", before, FamousDefs::FIXTURE);
 
         check_assist(
             fill_match_arms,
diff --git a/crates/ra_assists/src/handlers/fix_visibility.rs b/crates/ra_assists/src/handlers/fix_visibility.rs
index 531b3560f..54601d1f3 100644
--- a/crates/ra_assists/src/handlers/fix_visibility.rs
+++ b/crates/ra_assists/src/handlers/fix_visibility.rs
@@ -255,15 +255,14 @@ mod tests {
         check_assist(
             fix_visibility,
             r"
-              //- /main.rs
-              mod foo;
-              fn main() { foo::Foo<|> }
+//- /main.rs
+mod foo;
+fn main() { foo::Foo<|> }
 
-              //- /foo.rs
-              struct Foo;
-              ",
+//- /foo.rs
+struct Foo;
+",
             r"$0pub(crate) struct Foo;
-
 ",
         );
     }
@@ -279,14 +278,14 @@ mod tests {
         );
         check_assist(
             fix_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo { <|>bar: () }; }
-              //- /foo.rs
-              pub struct Foo { bar: () }
-              ",
+            r"
+//- /lib.rs
+mod foo;
+fn main() { foo::Foo { <|>bar: () }; }
+//- /foo.rs
+pub struct Foo { bar: () }
+",
             r"pub struct Foo { $0pub(crate) bar: () }
-
 ",
         );
         check_assist_not_applicable(
@@ -296,12 +295,13 @@ mod tests {
         );
         check_assist_not_applicable(
             fix_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo { <|>bar: () }; }
-              //- /foo.rs
-              pub struct Foo { pub bar: () }
-              ",
+            r"
+//- /lib.rs
+mod foo;
+fn main() { foo::Foo { <|>bar: () }; }
+//- /foo.rs
+pub struct Foo { pub bar: () }
+",
         );
     }
 
@@ -316,14 +316,14 @@ mod tests {
         );
         check_assist(
             fix_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo::Bar { <|>bar: () }; }
-              //- /foo.rs
-              pub enum Foo { Bar { bar: () } }
-              ",
+            r"
+//- /lib.rs
+mod foo;
+fn main() { foo::Foo::Bar { <|>bar: () }; }
+//- /foo.rs
+pub enum Foo { Bar { bar: () } }
+",
             r"pub enum Foo { Bar { $0pub(crate) bar: () } }
-
 ",
         );
         check_assist_not_applicable(
@@ -333,12 +333,13 @@ mod tests {
         );
         check_assist_not_applicable(
             fix_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo { <|>bar: () }; }
-              //- /foo.rs
-              pub struct Foo { pub bar: () }
-              ",
+            r"
+//- /lib.rs
+mod foo;
+fn main() { foo::Foo { <|>bar: () }; }
+//- /foo.rs
+pub struct Foo { pub bar: () }
+",
         );
     }
 
@@ -355,14 +356,14 @@ mod tests {
         );
         check_assist(
             fix_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo { <|>bar: () }; }
-              //- /foo.rs
-              pub union Foo { bar: () }
-              ",
+            r"
+//- /lib.rs
+mod foo;
+fn main() { foo::Foo { <|>bar: () }; }
+//- /foo.rs
+pub union Foo { bar: () }
+",
             r"pub union Foo { $0pub(crate) bar: () }
-
 ",
         );
         check_assist_not_applicable(
@@ -372,12 +373,13 @@ mod tests {
         );
         check_assist_not_applicable(
             fix_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo { <|>bar: () }; }
-              //- /foo.rs
-              pub union Foo { pub bar: () }
-              ",
+            r"
+//- /lib.rs
+mod foo;
+fn main() { foo::Foo { <|>bar: () }; }
+//- /foo.rs
+pub union Foo { pub bar: () }
+",
         );
     }
 
@@ -458,19 +460,18 @@ mod tests {
         check_assist(
             fix_visibility,
             r"
-            //- /main.rs
-            mod foo;
-            fn main() { foo::bar<|>::baz(); }
+//- /main.rs
+mod foo;
+fn main() { foo::bar<|>::baz(); }
 
-            //- /foo.rs
-            mod bar {
-                pub fn baz() {}
-            }
-            ",
+//- /foo.rs
+mod bar {
+    pub fn baz() {}
+}
+",
             r"$0pub(crate) mod bar {
     pub fn baz() {}
 }
-
 ",
         );
 
@@ -486,17 +487,15 @@ mod tests {
         check_assist(
             fix_visibility,
             r"
-            //- /main.rs
-            mod foo;
-            fn main() { foo::bar<|>::baz(); }
-
-            //- /foo.rs
-            mod bar;
-
-            //- /foo/bar.rs
-            pub fn baz() {}
-            }
-            ",
+//- /main.rs
+mod foo;
+fn main() { foo::bar<|>::baz(); }
+
+//- /foo.rs
+mod bar;
+//- /foo/bar.rs
+pub fn baz() {}
+",
             r"$0pub(crate) mod bar;
 ",
         );
@@ -506,14 +505,16 @@ mod tests {
     fn fix_visibility_of_module_declaration_in_other_file() {
         check_assist(
             fix_visibility,
-            r"//- /main.rs
-              mod foo;
-              fn main() { foo::bar<|>>::baz(); }
+            r"
+//- /main.rs
+mod foo;
+fn main() { foo::bar<|>>::baz(); }
 
-              //- /foo.rs
-              mod bar {
-                  pub fn baz() {}
-              }",
+//- /foo.rs
+mod bar {
+    pub fn baz() {}
+}
+",
             r"$0pub(crate) mod bar {
     pub fn baz() {}
 }
@@ -525,10 +526,12 @@ mod tests {
     fn adds_pub_when_target_is_in_another_crate() {
         check_assist(
             fix_visibility,
-            r"//- /main.rs crate:a deps:foo
-              foo::Bar<|>
-              //- /lib.rs crate:foo
-              struct Bar;",
+            r"
+//- /main.rs crate:a deps:foo
+foo::Bar<|>
+//- /lib.rs crate:foo
+struct Bar;
+",
             r"$0pub struct Bar;
 ",
         )
diff --git a/crates/ra_assists/src/handlers/introduce_variable.rs b/crates/ra_assists/src/handlers/introduce_variable.rs
index 31d6539f7..88b62278f 100644
--- a/crates/ra_assists/src/handlers/introduce_variable.rs
+++ b/crates/ra_assists/src/handlers/introduce_variable.rs
@@ -226,27 +226,31 @@ fn foo() {
         mark::check!(test_introduce_var_last_expr);
         check_assist(
             introduce_variable,
-            "
+            r#"
 fn foo() {
     bar(<|>1 + 1<|>)
-}",
-            "
+}
+"#,
+            r#"
 fn foo() {
     let $0var_name = 1 + 1;
     bar(var_name)
-}",
+}
+"#,
         );
         check_assist(
             introduce_variable,
-            "
+            r#"
 fn foo() {
     <|>bar(1 + 1)<|>
-}",
-            "
+}
+"#,
+            r#"
 fn foo() {
     let $0var_name = bar(1 + 1);
     var_name
-}",
+}
+"#,
         )
     }
 
diff --git a/crates/ra_assists/src/handlers/merge_imports.rs b/crates/ra_assists/src/handlers/merge_imports.rs
index 972d16241..ac0b3035c 100644
--- a/crates/ra_assists/src/handlers/merge_imports.rs
+++ b/crates/ra_assists/src/handlers/merge_imports.rs
@@ -127,7 +127,7 @@ fn first_path(path: &ast::Path) -> ast::Path {
 
 #[cfg(test)]
 mod tests {
-    use crate::tests::check_assist;
+    use crate::tests::{check_assist, check_assist_not_applicable};
 
     use super::*;
 
@@ -276,4 +276,14 @@ bar::baz};
 ",
         )
     }
+
+    #[test]
+    fn test_empty_use() {
+        check_assist_not_applicable(
+            merge_imports,
+            r"
+use std::<|>
+fn main() {}",
+        );
+    }
 }
diff --git a/crates/ra_assists/src/handlers/raw_string.rs b/crates/ra_assists/src/handlers/raw_string.rs
index 16002d2ac..d22d0aa55 100644
--- a/crates/ra_assists/src/handlers/raw_string.rs
+++ b/crates/ra_assists/src/handlers/raw_string.rs
@@ -158,16 +158,16 @@ mod test {
         check_assist(
             make_raw_string,
             r#"
-            fn f() {
-                let s = <|>"random\nstring";
-            }
-            "#,
+fn f() {
+    let s = <|>"random\nstring";
+}
+"#,
             r##"
-            fn f() {
-                let s = r#"random
+fn f() {
+    let s = r#"random
 string"#;
-            }
-            "##,
+}
+"##,
         )
     }
 
@@ -193,16 +193,16 @@ string"#;
         check_assist(
             make_raw_string,
             r###"
-            fn f() {
-                let s = <|>"#random##\nstring";
-            }
-            "###,
+fn f() {
+    let s = <|>"#random##\nstring";
+}
+"###,
             r####"
-            fn f() {
-                let s = r#"#random##
+fn f() {
+    let s = r#"#random##
 string"#;
-            }
-            "####,
+}
+"####,
         )
     }
 
@@ -211,16 +211,16 @@ string"#;
         check_assist(
             make_raw_string,
             r###"
-            fn f() {
-                let s = <|>"#random\"##\nstring";
-            }
-            "###,
+fn f() {
+    let s = <|>"#random\"##\nstring";
+}
+"###,
             r####"
-            fn f() {
-                let s = r###"#random"##
+fn f() {
+    let s = r###"#random"##
 string"###;
-            }
-            "####,
+}
+"####,
         )
     }
 
diff --git a/crates/ra_assists/src/handlers/split_import.rs b/crates/ra_assists/src/handlers/split_import.rs
index c7a874480..38aa199a0 100644
--- a/crates/ra_assists/src/handlers/split_import.rs
+++ b/crates/ra_assists/src/handlers/split_import.rs
@@ -66,4 +66,14 @@ mod tests {
     fn issue4044() {
         check_assist_not_applicable(split_import, "use crate::<|>:::self;")
     }
+
+    #[test]
+    fn test_empty_use() {
+        check_assist_not_applicable(
+            split_import,
+            r"
+use std::<|>
+fn main() {}",
+        );
+    }
 }
diff --git a/crates/ra_assists/src/tests.rs b/crates/ra_assists/src/tests.rs
index 62dd3547f..858f5ca80 100644
--- a/crates/ra_assists/src/tests.rs
+++ b/crates/ra_assists/src/tests.rs
@@ -1,27 +1,21 @@
 mod generated;
 
-use std::sync::Arc;
-
 use hir::Semantics;
 use ra_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
-use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
+use ra_ide_db::RootDatabase;
 use ra_syntax::TextRange;
-use test_utils::{
-    assert_eq_text, extract_offset, extract_range, extract_range_or_offset, RangeOrOffset,
-};
+use test_utils::{assert_eq_text, extract_offset, extract_range};
 
 use crate::{handlers::Handler, Assist, AssistConfig, AssistContext, Assists};
+use stdx::trim_indent;
 
 pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
-    let (mut db, file_id) = RootDatabase::with_single_file(text);
-    // FIXME: ideally, this should be done by the above `RootDatabase::with_single_file`,
-    // but it looks like this might need specialization? :(
-    db.set_local_roots(Arc::new(vec![db.file_source_root(file_id)]));
-    (db, file_id)
+    RootDatabase::with_single_file(text)
 }
 
 pub(crate) fn check_assist(assist: Handler, ra_fixture_before: &str, ra_fixture_after: &str) {
-    check(assist, ra_fixture_before, ExpectedResult::After(ra_fixture_after));
+    let ra_fixture_after = trim_indent(ra_fixture_after);
+    check(assist, ra_fixture_before, ExpectedResult::After(&ra_fixture_after));
 }
 
 // FIXME: instead of having a separate function here, maybe use
@@ -36,8 +30,9 @@ pub(crate) fn check_assist_not_applicable(assist: Handler, ra_fixture: &str) {
 }
 
 fn check_doc_test(assist_id: &str, before: &str, after: &str) {
-    let (selection, before) = extract_range_or_offset(before);
-    let (db, file_id) = crate::tests::with_single_file(&before);
+    let after = trim_indent(after);
+    let (db, file_id, selection) = RootDatabase::with_range_or_offset(&before);
+    let before = db.file_text(file_id).to_string();
     let frange = FileRange { file_id, range: selection.into() };
 
     let mut assist = Assist::resolved(&db, &AssistConfig::default(), frange)
@@ -57,11 +52,11 @@ fn check_doc_test(assist_id: &str, before: &str, after: &str) {
 
     let actual = {
         let change = assist.source_change.source_file_edits.pop().unwrap();
-        let mut actual = before.clone();
+        let mut actual = before;
         change.edit.apply(&mut actual);
         actual
     };
-    assert_eq_text!(after, &actual);
+    assert_eq_text!(&after, &actual);
 }
 
 enum ExpectedResult<'a> {
@@ -71,20 +66,8 @@ enum ExpectedResult<'a> {
 }
 
 fn check(handler: Handler, before: &str, expected: ExpectedResult) {
-    let (text_without_caret, file_with_caret_id, range_or_offset, db) = if before.contains("//-") {
-        let (mut db, position) = RootDatabase::with_position(before);
-        db.set_local_roots(Arc::new(vec![db.file_source_root(position.file_id)]));
-        (
-            db.file_text(position.file_id).as_ref().to_owned(),
-            position.file_id,
-            RangeOrOffset::Offset(position.offset),
-            db,
-        )
-    } else {
-        let (range_or_offset, text_without_caret) = extract_range_or_offset(before);
-        let (db, file_id) = with_single_file(&text_without_caret);
-        (text_without_caret, file_id, range_or_offset, db)
-    };
+    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();
 
     let frange = FileRange { file_id: file_with_caret_id, range: range_or_offset.into() };
 
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index c1ff0de7b..b7c45a619 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -198,8 +198,7 @@ pub(crate) struct FamousDefs<'a, 'b>(pub(crate) &'a Semantics<'b, RootDatabase>,
 #[allow(non_snake_case)]
 impl FamousDefs<'_, '_> {
     #[cfg(test)]
-    pub(crate) 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;
diff --git a/crates/ra_db/Cargo.toml b/crates/ra_db/Cargo.toml
index 8ab409158..372fb242b 100644
--- a/crates/ra_db/Cargo.toml
+++ b/crates/ra_db/Cargo.toml
@@ -17,3 +17,5 @@ ra_cfg = { path = "../ra_cfg" }
 ra_prof = { path = "../ra_prof" }
 ra_tt = { path = "../ra_tt" }
 test_utils = { path = "../test_utils" }
+vfs = { path = "../vfs" }
+stdx = { path = "../stdx" }
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index 482a2f3e6..4f4fb4494 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -57,17 +57,16 @@
 //! fn insert_source_code_here() {}
 //! "
 //! ```
-
-use std::str::FromStr;
-use std::sync::Arc;
+use std::{str::FromStr, sync::Arc};
 
 use ra_cfg::CfgOptions;
 use rustc_hash::FxHashMap;
-use test_utils::{extract_offset, parse_fixture, parse_single_fixture, FixtureMeta, CURSOR_MARKER};
+use test_utils::{extract_range_or_offset, Fixture, RangeOrOffset, CURSOR_MARKER};
+use vfs::{file_set::FileSet, VfsPath};
 
 use crate::{
-    input::CrateName, CrateGraph, CrateId, Edition, Env, FileId, FilePosition, RelativePathBuf,
-    SourceDatabaseExt, SourceRoot, SourceRootId,
+    input::CrateName, CrateGraph, CrateId, Edition, Env, FileId, FilePosition, SourceDatabaseExt,
+    SourceRoot, SourceRootId,
 };
 
 pub const WORKSPACE: SourceRootId = SourceRootId(0);
@@ -75,21 +74,32 @@ pub const WORKSPACE: SourceRootId = SourceRootId(0);
 pub trait WithFixture: Default + SourceDatabaseExt + 'static {
     fn with_single_file(text: &str) -> (Self, FileId) {
         let mut db = Self::default();
-        let file_id = with_single_file(&mut db, text);
-        (db, file_id)
+        let (_, files) = with_files(&mut db, text);
+        assert_eq!(files.len(), 1);
+        (db, files[0])
     }
 
     fn with_files(ra_fixture: &str) -> Self {
         let mut db = Self::default();
-        let pos = with_files(&mut db, ra_fixture);
+        let (pos, _) = with_files(&mut db, ra_fixture);
         assert!(pos.is_none());
         db
     }
 
     fn with_position(ra_fixture: &str) -> (Self, FilePosition) {
+        let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
+        let offset = match range_or_offset {
+            RangeOrOffset::Range(_) => panic!(),
+            RangeOrOffset::Offset(it) => it,
+        };
+        (db, FilePosition { file_id, offset })
+    }
+
+    fn with_range_or_offset(ra_fixture: &str) -> (Self, FileId, RangeOrOffset) {
         let mut db = Self::default();
-        let pos = with_files(&mut db, ra_fixture);
-        (db, pos.unwrap())
+        let (pos, _) = with_files(&mut db, ra_fixture);
+        let (file_id, range_or_offset) = pos.unwrap();
+        (db, file_id, range_or_offset)
     }
 
     fn test_crate(&self) -> CrateId {
@@ -103,83 +113,36 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
 
 impl<DB: SourceDatabaseExt + Default + 'static> WithFixture for DB {}
 
-fn with_single_file(db: &mut dyn SourceDatabaseExt, ra_fixture: &str) -> FileId {
-    let file_id = FileId(0);
-    let rel_path: RelativePathBuf = "/main.rs".into();
-
-    let mut source_root = SourceRoot::new_local();
-    source_root.insert_file(rel_path.clone(), file_id);
-
-    let fixture = parse_single_fixture(ra_fixture);
-
-    let crate_graph = if let Some(entry) = fixture {
-        let meta = match ParsedMeta::from(&entry.meta) {
-            ParsedMeta::File(it) => it,
-            _ => panic!("with_single_file only support file meta"),
-        };
-
-        let mut crate_graph = CrateGraph::default();
-        crate_graph.add_crate_root(
-            file_id,
-            meta.edition,
-            meta.krate.map(|name| {
-                CrateName::new(&name).expect("Fixture crate name should not contain dashes")
-            }),
-            meta.cfg,
-            meta.env,
-            Default::default(),
-            Default::default(),
-        );
-        crate_graph
-    } else {
-        let mut crate_graph = CrateGraph::default();
-        crate_graph.add_crate_root(
-            file_id,
-            Edition::Edition2018,
-            None,
-            CfgOptions::default(),
-            Env::default(),
-            Default::default(),
-            Default::default(),
-        );
-        crate_graph
-    };
-
-    db.set_file_text(file_id, Arc::new(ra_fixture.to_string()));
-    db.set_file_relative_path(file_id, rel_path);
-    db.set_file_source_root(file_id, WORKSPACE);
-    db.set_source_root(WORKSPACE, Arc::new(source_root));
-    db.set_crate_graph(Arc::new(crate_graph));
-
-    file_id
-}
-
-fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosition> {
-    let fixture = parse_fixture(fixture);
+fn with_files(
+    db: &mut dyn SourceDatabaseExt,
+    fixture: &str,
+) -> (Option<(FileId, RangeOrOffset)>, Vec<FileId>) {
+    let fixture = Fixture::parse(fixture);
 
+    let mut files = Vec::new();
     let mut crate_graph = CrateGraph::default();
     let mut crates = FxHashMap::default();
     let mut crate_deps = Vec::new();
     let mut default_crate_root: Option<FileId> = None;
 
-    let mut source_root = SourceRoot::new_local();
-    let mut source_root_id = WORKSPACE;
-    let mut source_root_prefix: RelativePathBuf = "/".into();
+    let mut file_set = FileSet::default();
+    let source_root_id = WORKSPACE;
+    let source_root_prefix = "/".to_string();
     let mut file_id = FileId(0);
 
     let mut file_position = None;
 
-    for entry in fixture.iter() {
-        let meta = match ParsedMeta::from(&entry.meta) {
-            ParsedMeta::Root { path } => {
-                let source_root = std::mem::replace(&mut source_root, SourceRoot::new_local());
-                db.set_source_root(source_root_id, Arc::new(source_root));
-                source_root_id.0 += 1;
-                source_root_prefix = path;
-                continue;
-            }
-            ParsedMeta::File(it) => it,
+    for entry in fixture {
+        let text = if entry.text.contains(CURSOR_MARKER) {
+            let (range_or_offset, text) = extract_range_or_offset(&entry.text);
+            assert!(file_position.is_none());
+            file_position = Some((file_id, range_or_offset));
+            text.to_string()
+        } else {
+            entry.text.clone()
         };
+
+        let meta = FileMeta::from(entry);
         assert!(meta.path.starts_with(&source_root_prefix));
 
         if let Some(krate) = meta.krate {
@@ -190,7 +153,6 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
                 meta.cfg,
                 meta.env,
                 Default::default(),
-                Default::default(),
             );
             let prev = crates.insert(krate.clone(), crate_id);
             assert!(prev.is_none());
@@ -202,20 +164,11 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
             default_crate_root = Some(file_id);
         }
 
-        let text = if entry.text.contains(CURSOR_MARKER) {
-            let (offset, text) = extract_offset(&entry.text);
-            assert!(file_position.is_none());
-            file_position = Some(FilePosition { file_id, offset });
-            text.to_string()
-        } else {
-            entry.text.to_string()
-        };
-
         db.set_file_text(file_id, Arc::new(text));
-        db.set_file_relative_path(file_id, meta.path.clone());
         db.set_file_source_root(file_id, source_root_id);
-        source_root.insert_file(meta.path, file_id);
-
+        let path = VfsPath::new_virtual_path(meta.path);
+        file_set.insert(file_id, path.into());
+        files.push(file_id);
         file_id.0 += 1;
     }
 
@@ -228,7 +181,6 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
             CfgOptions::default(),
             Env::default(),
             Default::default(),
-            Default::default(),
         );
     } else {
         for (from, to) in crate_deps {
@@ -238,19 +190,14 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
         }
     }
 
-    db.set_source_root(source_root_id, Arc::new(source_root));
+    db.set_source_root(source_root_id, Arc::new(SourceRoot::new_local(file_set)));
     db.set_crate_graph(Arc::new(crate_graph));
 
-    file_position
-}
-
-enum ParsedMeta {
-    Root { path: RelativePathBuf },
-    File(FileMeta),
+    (file_position, files)
 }
 
 struct FileMeta {
-    path: RelativePathBuf,
+    path: String,
     krate: Option<String>,
     deps: Vec<String>,
     cfg: CfgOptions,
@@ -258,25 +205,22 @@ struct FileMeta {
     env: Env,
 }
 
-impl From<&FixtureMeta> for ParsedMeta {
-    fn from(meta: &FixtureMeta) -> Self {
-        match meta {
-            FixtureMeta::Root { path } => {
-                // `Self::Root` causes a false warning: 'variant is never constructed: `Root` '
-                // see https://github.com/rust-lang/rust/issues/69018
-                ParsedMeta::Root { path: path.to_owned() }
-            }
-            FixtureMeta::File(f) => Self::File(FileMeta {
-                path: f.path.to_owned(),
-                krate: f.crate_name.to_owned(),
-                deps: f.deps.to_owned(),
-                cfg: f.cfg.to_owned(),
-                edition: f
-                    .edition
-                    .as_ref()
-                    .map_or(Edition::Edition2018, |v| Edition::from_str(&v).unwrap()),
-                env: Env::from(f.env.iter()),
-            }),
+impl From<Fixture> for FileMeta {
+    fn from(f: Fixture) -> FileMeta {
+        let mut cfg = CfgOptions::default();
+        f.cfg_atoms.iter().for_each(|it| cfg.insert_atom(it.into()));
+        f.cfg_key_values.iter().for_each(|(k, v)| cfg.insert_key_value(k.into(), v.into()));
+
+        FileMeta {
+            path: f.path,
+            krate: f.krate,
+            deps: f.deps,
+            cfg,
+            edition: f
+                .edition
+                .as_ref()
+                .map_or(Edition::Edition2018, |v| Edition::from_str(&v).unwrap()),
+            env: Env::from(f.env.iter()),
         }
     }
 }
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index bf26048f2..7f3660118 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -6,27 +6,15 @@
 //! actual IO. See `vfs` and `project_model` in the `rust-analyzer` crate for how
 //! actual IO is done and lowered to input.
 
-use std::{
-    fmt, ops,
-    path::{Path, PathBuf},
-    str::FromStr,
-    sync::Arc,
-};
+use std::{fmt, ops, str::FromStr, sync::Arc};
 
 use ra_cfg::CfgOptions;
 use ra_syntax::SmolStr;
 use ra_tt::TokenExpander;
 use rustc_hash::{FxHashMap, FxHashSet};
+use vfs::file_set::FileSet;
 
-use crate::{RelativePath, RelativePathBuf};
-
-/// `FileId` is an integer which uniquely identifies a file. File paths are
-/// messy and system-dependent, so most of the code should work directly with
-/// `FileId`, without inspecting the path. The mapping between `FileId` and path
-/// and `SourceRoot` is constant. A file rename is represented as a pair of
-/// deletion/creation.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct FileId(pub u32);
+pub use vfs::FileId;
 
 /// Files are grouped into source roots. A source root is a directory on the
 /// file systems which is watched for changes. Typically it corresponds to a
@@ -45,27 +33,18 @@ pub struct SourceRoot {
     /// Libraries are considered mostly immutable, this assumption is used to
     /// optimize salsa's query structure
     pub is_library: bool,
-    files: FxHashMap<RelativePathBuf, FileId>,
+    pub(crate) file_set: FileSet,
 }
 
 impl SourceRoot {
-    pub fn new_local() -> SourceRoot {
-        SourceRoot { is_library: false, files: Default::default() }
-    }
-    pub fn new_library() -> SourceRoot {
-        SourceRoot { is_library: true, files: Default::default() }
-    }
-    pub fn insert_file(&mut self, path: RelativePathBuf, file_id: FileId) {
-        self.files.insert(path, file_id);
+    pub fn new_local(file_set: FileSet) -> SourceRoot {
+        SourceRoot { is_library: false, file_set }
     }
-    pub fn remove_file(&mut self, path: &RelativePath) {
-        self.files.remove(path);
+    pub fn new_library(file_set: FileSet) -> SourceRoot {
+        SourceRoot { is_library: true, file_set }
     }
-    pub fn walk(&self) -> impl Iterator<Item = FileId> + '_ {
-        self.files.values().copied()
-    }
-    pub fn file_by_relative_path(&self, path: &RelativePath) -> Option<FileId> {
-        self.files.get(path).copied()
+    pub fn iter(&self) -> impl Iterator<Item = FileId> + '_ {
+        self.file_set.iter()
     }
 }
 
@@ -141,7 +120,6 @@ pub struct CrateData {
     pub display_name: Option<CrateName>,
     pub cfg_options: CfgOptions,
     pub env: Env,
-    pub extern_source: ExternSource,
     pub dependencies: Vec<Dependency>,
     pub proc_macro: Vec<ProcMacro>,
 }
@@ -152,22 +130,11 @@ pub enum Edition {
     Edition2015,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ExternSourceId(pub u32);
-
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct Env {
     entries: FxHashMap<String, String>,
 }
 
-// FIXME: Redesign vfs for solve the following limitation ?
-// Note: Some env variables (e.g. OUT_DIR) are located outside of the
-// crate. We store a map to allow remap it to ExternSourceId
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub struct ExternSource {
-    extern_paths: FxHashMap<PathBuf, ExternSourceId>,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Dependency {
     pub crate_id: CrateId,
@@ -182,7 +149,6 @@ impl CrateGraph {
         display_name: Option<CrateName>,
         cfg_options: CfgOptions,
         env: Env,
-        extern_source: ExternSource,
         proc_macro: Vec<(SmolStr, Arc<dyn ra_tt::TokenExpander>)>,
     ) -> CrateId {
         let proc_macro =
@@ -194,7 +160,6 @@ impl CrateGraph {
             display_name,
             cfg_options,
             env,
-            extern_source,
             proc_macro,
             dependencies: Vec::new(),
         };
@@ -254,12 +219,12 @@ impl CrateGraph {
             return false;
         }
 
+        if target == from {
+            return true;
+        }
+
         for dep in &self[from].dependencies {
             let crate_id = dep.crate_id;
-            if crate_id == target {
-                return true;
-            }
-
             if self.dfs_find(target, crate_id, visited) {
                 return true;
             }
@@ -334,20 +299,6 @@ impl Env {
     }
 }
 
-impl ExternSource {
-    pub fn extern_path(&self, path: &Path) -> Option<(ExternSourceId, RelativePathBuf)> {
-        self.extern_paths.iter().find_map(|(root_path, id)| {
-            let rel_path = path.strip_prefix(root_path).ok()?;
-            let rel_path = RelativePathBuf::from_path(rel_path).ok()?;
-            Some((*id, rel_path))
-        })
-    }
-
-    pub fn set_extern_path(&mut self, root_path: &Path, root: ExternSourceId) {
-        self.extern_paths.insert(root_path.to_path_buf(), root);
-    }
-}
-
 #[derive(Debug)]
 pub struct ParseEditionError {
     invalid_input: String,
@@ -369,7 +320,7 @@ mod tests {
     use super::{CfgOptions, CrateGraph, CrateName, Dependency, Edition::Edition2018, Env, FileId};
 
     #[test]
-    fn it_should_panic_because_of_cycle_dependencies() {
+    fn detect_cyclic_dependency_indirect() {
         let mut graph = CrateGraph::default();
         let crate1 = graph.add_crate_root(
             FileId(1u32),
@@ -378,7 +329,6 @@ mod tests {
             CfgOptions::default(),
             Env::default(),
             Default::default(),
-            Default::default(),
         );
         let crate2 = graph.add_crate_root(
             FileId(2u32),
@@ -387,7 +337,6 @@ mod tests {
             CfgOptions::default(),
             Env::default(),
             Default::default(),
-            Default::default(),
         );
         let crate3 = graph.add_crate_root(
             FileId(3u32),
@@ -396,7 +345,6 @@ mod tests {
             CfgOptions::default(),
             Env::default(),
             Default::default(),
-            Default::default(),
         );
         assert!(graph.add_dep(crate1, CrateName::new("crate2").unwrap(), crate2).is_ok());
         assert!(graph.add_dep(crate2, CrateName::new("crate3").unwrap(), crate3).is_ok());
@@ -404,7 +352,7 @@ mod tests {
     }
 
     #[test]
-    fn it_works() {
+    fn detect_cyclic_dependency_direct() {
         let mut graph = CrateGraph::default();
         let crate1 = graph.add_crate_root(
             FileId(1u32),
@@ -413,7 +361,6 @@ mod tests {
             CfgOptions::default(),
             Env::default(),
             Default::default(),
-            Default::default(),
         );
         let crate2 = graph.add_crate_root(
             FileId(2u32),
@@ -422,6 +369,28 @@ mod tests {
             CfgOptions::default(),
             Env::default(),
             Default::default(),
+        );
+        assert!(graph.add_dep(crate1, CrateName::new("crate2").unwrap(), crate2).is_ok());
+        assert!(graph.add_dep(crate2, CrateName::new("crate2").unwrap(), crate2).is_err());
+    }
+
+    #[test]
+    fn it_works() {
+        let mut graph = CrateGraph::default();
+        let crate1 = graph.add_crate_root(
+            FileId(1u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+        );
+        let crate2 = graph.add_crate_root(
+            FileId(2u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
             Default::default(),
         );
         let crate3 = graph.add_crate_root(
@@ -431,7 +400,6 @@ mod tests {
             CfgOptions::default(),
             Env::default(),
             Default::default(),
-            Default::default(),
         );
         assert!(graph.add_dep(crate1, CrateName::new("crate2").unwrap(), crate2).is_ok());
         assert!(graph.add_dep(crate2, CrateName::new("crate3").unwrap(), crate3).is_ok());
@@ -447,7 +415,6 @@ mod tests {
             CfgOptions::default(),
             Env::default(),
             Default::default(),
-            Default::default(),
         );
         let crate2 = graph.add_crate_root(
             FileId(2u32),
@@ -456,7 +423,6 @@ mod tests {
             CfgOptions::default(),
             Env::default(),
             Default::default(),
-            Default::default(),
         );
         assert!(graph
             .add_dep(crate1, CrateName::normalize_dashes("crate-name-with-dashes"), crate2)
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index 80ddb6058..4a3ba57da 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -12,12 +12,13 @@ use rustc_hash::FxHashSet;
 pub use crate::{
     cancellation::Canceled,
     input::{
-        CrateData, CrateGraph, CrateId, CrateName, Dependency, Edition, Env, ExternSource,
-        ExternSourceId, FileId, ProcMacroId, SourceRoot, SourceRootId,
+        CrateData, CrateGraph, CrateId, CrateName, Dependency, Edition, Env, FileId, ProcMacroId,
+        SourceRoot, SourceRootId,
     },
 };
 pub use relative_path::{RelativePath, RelativePathBuf};
 pub use salsa;
+pub use vfs::{file_set::FileSet, AbsPathBuf, VfsPath};
 
 #[macro_export]
 macro_rules! impl_intern_key {
@@ -113,7 +114,7 @@ pub trait SourceDatabase: CheckCanceled + FileLoader + std::fmt::Debug {
 }
 
 fn parse_query(db: &impl SourceDatabase, file_id: FileId) -> Parse<ast::SourceFile> {
-    let _p = profile("parse_query");
+    let _p = profile("parse_query").detail(|| format!("{:?}", file_id));
     let text = db.file_text(file_id);
     SourceFile::parse(&*text)
 }
@@ -125,8 +126,6 @@ pub trait SourceDatabaseExt: SourceDatabase {
     #[salsa::input]
     fn file_text(&self, file_id: FileId) -> Arc<String>;
     /// Path to a file, relative to the root of its source root.
-    #[salsa::input]
-    fn file_relative_path(&self, file_id: FileId) -> RelativePathBuf;
     /// Source root of the file.
     #[salsa::input]
     fn file_source_root(&self, file_id: FileId) -> SourceRootId;
@@ -161,24 +160,9 @@ impl<T: SourceDatabaseExt> FileLoader for FileLoaderDelegate<&'_ T> {
     }
     fn resolve_path(&self, anchor: FileId, path: &str) -> Option<FileId> {
         // FIXME: this *somehow* should be platform agnostic...
-        if std::path::Path::new(path).is_absolute() {
-            let krate = *self.relevant_crates(anchor).iter().next()?;
-            let (extern_source_id, relative_file) =
-                self.0.crate_graph()[krate].extern_source.extern_path(path.as_ref())?;
-
-            let source_root = self.0.source_root(SourceRootId(extern_source_id.0));
-            source_root.file_by_relative_path(&relative_file)
-        } else {
-            let rel_path = {
-                let mut rel_path = self.0.file_relative_path(anchor);
-                assert!(rel_path.pop());
-                rel_path.push(path);
-                rel_path.normalize()
-            };
-            let source_root = self.0.file_source_root(anchor);
-            let source_root = self.0.source_root(source_root);
-            source_root.file_by_relative_path(&rel_path)
-        }
+        let source_root = self.0.file_source_root(anchor);
+        let source_root = self.0.source_root(source_root);
+        source_root.file_set.resolve_path(anchor, path)
     }
 
     fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 1a9f6cc76..a379b9f49 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -26,15 +26,12 @@ use hir_ty::{
     autoderef,
     display::{HirDisplayError, HirFormatter},
     expr::ExprValidator,
-    method_resolution, ApplicationTy, Canonical, InEnvironment, Substs, TraitEnvironment, Ty,
-    TyDefId, TypeCtor,
+    method_resolution, ApplicationTy, Canonical, GenericPredicate, InEnvironment, Substs,
+    TraitEnvironment, Ty, TyDefId, TypeCtor,
 };
 use ra_db::{CrateId, CrateName, Edition, FileId};
 use ra_prof::profile;
-use ra_syntax::{
-    ast::{self, AttrsOwner, NameOwner},
-    AstNode,
-};
+use ra_syntax::ast::{self, AttrsOwner, NameOwner};
 use rustc_hash::FxHashSet;
 
 use crate::{
@@ -186,10 +183,27 @@ impl ModuleDef {
 
         module.visibility_of(db, self)
     }
+
+    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
+        match self {
+            ModuleDef::Adt(it) => Some(it.name(db)),
+            ModuleDef::Trait(it) => Some(it.name(db)),
+            ModuleDef::Function(it) => Some(it.name(db)),
+            ModuleDef::EnumVariant(it) => Some(it.name(db)),
+            ModuleDef::TypeAlias(it) => Some(it.name(db)),
+
+            ModuleDef::Module(it) => it.name(db),
+            ModuleDef::Const(it) => it.name(db),
+            ModuleDef::Static(it) => it.name(db),
+
+            ModuleDef::BuiltinType(it) => Some(it.as_name()),
+        }
+    }
 }
 
 pub use hir_def::{
-    attr::Attrs, item_scope::ItemInNs, visibility::Visibility, AssocItemId, AssocItemLoc,
+    attr::Attrs, item_scope::ItemInNs, item_tree::ItemTreeNode, visibility::Visibility,
+    AssocItemId, AssocItemLoc,
 };
 
 impl Module {
@@ -856,7 +870,7 @@ where
     ID: Lookup<Data = AssocItemLoc<AST>>,
     DEF: From<ID>,
     CTOR: FnOnce(DEF) -> AssocItem,
-    AST: AstNode,
+    AST: ItemTreeNode,
 {
     match id.lookup(db.upcast()).container {
         AssocContainerId::TraitId(_) | AssocContainerId::ImplId(_) => Some(ctor(DEF::from(id))),
@@ -1359,6 +1373,27 @@ impl Type {
         Some(adt.into())
     }
 
+    pub fn as_dyn_trait(&self) -> Option<Trait> {
+        self.ty.value.dyn_trait().map(Into::into)
+    }
+
+    pub fn as_impl_traits(&self, db: &dyn HirDatabase) -> Option<Vec<Trait>> {
+        self.ty.value.impl_trait_bounds(db).map(|it| {
+            it.into_iter()
+                .filter_map(|pred| match pred {
+                    hir_ty::GenericPredicate::Implemented(trait_ref) => {
+                        Some(Trait::from(trait_ref.trait_))
+                    }
+                    _ => None,
+                })
+                .collect()
+        })
+    }
+
+    pub fn as_associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<Trait> {
+        self.ty.value.associated_type_parent_trait(db).map(Into::into)
+    }
+
     // FIXME: provide required accessors such that it becomes implementable from outside.
     pub fn is_equal_for_find_impls(&self, other: &Type) -> bool {
         match (&self.ty.value, &other.ty.value) {
@@ -1380,6 +1415,80 @@ impl Type {
             ty: InEnvironment { value: ty, environment: self.ty.environment.clone() },
         }
     }
+
+    pub fn walk(&self, db: &dyn HirDatabase, mut cb: impl FnMut(Type)) {
+        // TypeWalk::walk for a Ty at first visits parameters and only after that the Ty itself.
+        // We need a different order here.
+
+        fn walk_substs(
+            db: &dyn HirDatabase,
+            type_: &Type,
+            substs: &Substs,
+            cb: &mut impl FnMut(Type),
+        ) {
+            for ty in substs.iter() {
+                walk_type(db, &type_.derived(ty.clone()), cb);
+            }
+        }
+
+        fn walk_bounds(
+            db: &dyn HirDatabase,
+            type_: &Type,
+            bounds: &[GenericPredicate],
+            cb: &mut impl FnMut(Type),
+        ) {
+            for pred in bounds {
+                match pred {
+                    GenericPredicate::Implemented(trait_ref) => {
+                        cb(type_.clone());
+                        walk_substs(db, type_, &trait_ref.substs, cb);
+                    }
+                    _ => (),
+                }
+            }
+        }
+
+        fn walk_type(db: &dyn HirDatabase, type_: &Type, cb: &mut impl FnMut(Type)) {
+            let ty = type_.ty.value.strip_references();
+            match ty {
+                Ty::Apply(ApplicationTy { ctor, parameters }) => {
+                    match ctor {
+                        TypeCtor::Adt(_) => {
+                            cb(type_.derived(ty.clone()));
+                        }
+                        TypeCtor::AssociatedType(_) => {
+                            if let Some(_) = ty.associated_type_parent_trait(db) {
+                                cb(type_.derived(ty.clone()));
+                            }
+                        }
+                        _ => (),
+                    }
+
+                    // adt params, tuples, etc...
+                    walk_substs(db, type_, parameters, cb);
+                }
+                Ty::Opaque(opaque_ty) => {
+                    if let Some(bounds) = ty.impl_trait_bounds(db) {
+                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
+                    }
+
+                    walk_substs(db, type_, &opaque_ty.parameters, cb);
+                }
+                Ty::Placeholder(_) => {
+                    if let Some(bounds) = ty.impl_trait_bounds(db) {
+                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
+                    }
+                }
+                Ty::Dyn(bounds) => {
+                    walk_bounds(db, &type_.derived(ty.clone()), bounds.as_ref(), cb);
+                }
+
+                _ => (),
+            }
+        }
+
+        walk_type(db, self, &mut cb);
+    }
 }
 
 impl HirDisplay for Type {
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index b6b665de1..bb67952de 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -6,7 +6,7 @@ pub use hir_def::db::{
     ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, ImportMapQuery,
     InternConstQuery, InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery,
     InternImplQuery, InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery,
-    InternUnionQuery, LangItemQuery, ModuleLangItemsQuery, RawItemsQuery, StaticDataQuery,
+    InternUnionQuery, ItemTreeQuery, LangItemQuery, ModuleLangItemsQuery, StaticDataQuery,
     StructDataQuery, TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
 };
 pub use hir_expand::db::{
@@ -16,7 +16,7 @@ pub use hir_expand::db::{
 pub use hir_ty::db::{
     AssociatedTyDataQuery, AssociatedTyValueQuery, CallableItemSignatureQuery, FieldTypesQuery,
     GenericDefaultsQuery, GenericPredicatesForParamQuery, GenericPredicatesQuery, HirDatabase,
-    HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery, ImplsForTraitQuery,
+    HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery, ImplsFromDepsQuery,
     ImplsInCrateQuery, InferQueryQuery, InternAssocTyValueQuery, InternChalkImplQuery,
     InternTypeCtorQuery, InternTypeParamIdQuery, ReturnTypeImplTraitsQuery, StructDatumQuery,
     TraitDatumQuery, TraitSolveQuery, TyQuery, ValueTyQuery,
diff --git a/crates/ra_hir/src/has_source.rs b/crates/ra_hir/src/has_source.rs
index 63b8fd369..76c32fc17 100644
--- a/crates/ra_hir/src/has_source.rs
+++ b/crates/ra_hir/src/has_source.rs
@@ -2,7 +2,7 @@
 
 use either::Either;
 use hir_def::{
-    nameres::ModuleSource,
+    nameres::{ModuleOrigin, ModuleSource},
     src::{HasChildSource, HasSource as _},
     Lookup, VariantId,
 };
@@ -29,6 +29,14 @@ impl Module {
         def_map[self.id.local_id].definition_source(db.upcast())
     }
 
+    pub fn is_mod_rs(self, db: &dyn HirDatabase) -> bool {
+        let def_map = db.crate_def_map(self.id.krate);
+        match def_map[self.id.local_id].origin {
+            ModuleOrigin::File { is_mod_rs, .. } => is_mod_rs,
+            _ => false,
+        }
+    }
+
     /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
     /// `None` for the crate root.
     pub fn declaration_source(self, db: &dyn HirDatabase) -> Option<InFile<ast::Module>> {
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index a232a5856..6a49c424a 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -6,9 +6,9 @@ use std::{cell::RefCell, fmt, iter::successors};
 
 use hir_def::{
     resolver::{self, HasResolver, Resolver},
-    AsMacroCall, TraitId,
+    AsMacroCall, TraitId, VariantId,
 };
-use hir_expand::{hygiene::Hygiene, ExpansionInfo};
+use hir_expand::{diagnostics::AstDiagnostic, hygiene::Hygiene, ExpansionInfo};
 use hir_ty::associated_type_shorthand_candidates;
 use itertools::Itertools;
 use ra_db::{FileId, FileRange};
@@ -104,6 +104,13 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         tree
     }
 
+    pub fn ast<T: AstDiagnostic + Diagnostic>(&self, d: &T) -> <T as AstDiagnostic>::AST {
+        let file_id = d.source().file_id;
+        let root = self.db.parse_or_expand(file_id).unwrap();
+        self.cache(root, file_id);
+        d.ast(self.db)
+    }
+
     pub fn expand(&self, macro_call: &ast::MacroCall) -> Option<SyntaxNode> {
         let macro_call = self.find_file(macro_call.syntax().clone()).with_value(macro_call);
         let sa = self.analyze2(macro_call.map(|it| it.syntax()), None);
@@ -247,6 +254,10 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         self.analyze(path.syntax()).resolve_path(self.db, path)
     }
 
+    pub fn resolve_variant(&self, record_lit: ast::RecordLit) -> Option<VariantId> {
+        self.analyze(record_lit.syntax()).resolve_variant(self.db, record_lit)
+    }
+
     pub fn lower_path(&self, path: &ast::Path) -> Option<Path> {
         let src = self.find_file(path.syntax().clone());
         Path::from_src(path.clone(), &Hygiene::new(self.db.upcast(), src.file_id.into()))
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index 7c6bbea13..1d6c47103 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -216,13 +216,43 @@ impl SourceAnalyzer {
             if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_expr(expr_id) {
                 return Some(PathResolution::AssocItem(assoc.into()));
             }
+            if let Some(VariantId::EnumVariantId(variant)) =
+                self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
+            {
+                return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+            }
         }
+
         if let Some(path_pat) = path.syntax().parent().and_then(ast::PathPat::cast) {
             let pat_id = self.pat_id(&path_pat.into())?;
             if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_pat(pat_id) {
                 return Some(PathResolution::AssocItem(assoc.into()));
             }
+            if let Some(VariantId::EnumVariantId(variant)) =
+                self.infer.as_ref()?.variant_resolution_for_pat(pat_id)
+            {
+                return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+            }
+        }
+
+        if let Some(rec_lit) = path.syntax().parent().and_then(ast::RecordLit::cast) {
+            let expr_id = self.expr_id(db, &rec_lit.into())?;
+            if let Some(VariantId::EnumVariantId(variant)) =
+                self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
+            {
+                return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+            }
         }
+
+        if let Some(rec_pat) = path.syntax().parent().and_then(ast::RecordPat::cast) {
+            let pat_id = self.pat_id(&rec_pat.into())?;
+            if let Some(VariantId::EnumVariantId(variant)) =
+                self.infer.as_ref()?.variant_resolution_for_pat(pat_id)
+            {
+                return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+            }
+        }
+
         // This must be a normal source file rather than macro file.
         let hir_path =
             crate::Path::from_src(path.clone(), &Hygiene::new(db.upcast(), self.file_id))?;
@@ -313,6 +343,16 @@ impl SourceAnalyzer {
         })?;
         Some(macro_call_id.as_file())
     }
+
+    pub(crate) fn resolve_variant(
+        &self,
+        db: &dyn HirDatabase,
+        record_lit: ast::RecordLit,
+    ) -> Option<VariantId> {
+        let infer = self.infer.as_ref()?;
+        let expr_id = self.expr_id(db, &record_lit.into())?;
+        infer.variant_resolution_for_expr(expr_id)
+    }
 }
 
 fn scope_for(
diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index ef1f65ee0..6d43924e3 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -17,6 +17,7 @@ drop_bomb = "0.1.4"
 fst = { version = "0.4", default-features = false }
 itertools = "0.9.0"
 indexmap = "1.4.0"
+smallvec = "1.4.0"
 
 stdx = { path = "../stdx" }
 
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 2eeba0572..197737ffc 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -13,7 +13,11 @@ use ra_syntax::{
 use tt::Subtree;
 
 use crate::{
-    db::DefDatabase, nameres::ModuleSource, path::ModPath, src::HasChildSource, src::HasSource,
+    db::DefDatabase,
+    item_tree::{ItemTreeId, ItemTreeNode},
+    nameres::ModuleSource,
+    path::ModPath,
+    src::HasChildSource,
     AdtId, AttrDefId, Lookup,
 };
 
@@ -34,6 +38,8 @@ impl ops::Deref for Attrs {
 }
 
 impl Attrs {
+    pub const EMPTY: Attrs = Attrs { entries: None };
+
     pub(crate) fn attrs_query(db: &dyn DefDatabase, def: AttrDefId) -> Attrs {
         match def {
             AttrDefId::ModuleId(module) => {
@@ -65,19 +71,19 @@ impl Attrs {
                 Attrs::from_attrs_owner(db, src.map(|it| it as &dyn AttrsOwner))
             }
             AttrDefId::AdtId(it) => match it {
-                AdtId::StructId(it) => attrs_from_loc(it.lookup(db), db),
-                AdtId::EnumId(it) => attrs_from_loc(it.lookup(db), db),
-                AdtId::UnionId(it) => attrs_from_loc(it.lookup(db), db),
+                AdtId::StructId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+                AdtId::EnumId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+                AdtId::UnionId(it) => attrs_from_item_tree(it.lookup(db).id, db),
             },
-            AttrDefId::TraitId(it) => attrs_from_loc(it.lookup(db), db),
+            AttrDefId::TraitId(it) => attrs_from_item_tree(it.lookup(db).id, db),
             AttrDefId::MacroDefId(it) => {
                 it.ast_id.map_or_else(Default::default, |ast_id| attrs_from_ast(ast_id, db))
             }
-            AttrDefId::ImplId(it) => attrs_from_loc(it.lookup(db), db),
-            AttrDefId::ConstId(it) => attrs_from_loc(it.lookup(db), db),
-            AttrDefId::StaticId(it) => attrs_from_loc(it.lookup(db), db),
-            AttrDefId::FunctionId(it) => attrs_from_loc(it.lookup(db), db),
-            AttrDefId::TypeAliasId(it) => attrs_from_loc(it.lookup(db), db),
+            AttrDefId::ImplId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::ConstId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::StaticId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::FunctionId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::TypeAliasId(it) => attrs_from_item_tree(it.lookup(db).id, db),
         }
     }
 
@@ -103,6 +109,18 @@ impl Attrs {
         Attrs { entries }
     }
 
+    pub fn merge(&self, other: Attrs) -> Attrs {
+        match (&self.entries, &other.entries) {
+            (None, None) => Attrs { entries: None },
+            (Some(entries), None) | (None, Some(entries)) => {
+                Attrs { entries: Some(entries.clone()) }
+            }
+            (Some(a), Some(b)) => {
+                Attrs { entries: Some(a.iter().chain(b.iter()).cloned().collect()) }
+            }
+        }
+    }
+
     pub fn by_key(&self, key: &'static str) -> AttrQuery<'_> {
         AttrQuery { attrs: self, key }
     }
@@ -187,11 +205,8 @@ where
     Attrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn AttrsOwner))
 }
 
-fn attrs_from_loc<T>(node: T, db: &dyn DefDatabase) -> Attrs
-where
-    T: HasSource,
-    T::Value: ast::AttrsOwner,
-{
-    let src = node.source(db);
-    Attrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn AttrsOwner))
+fn attrs_from_item_tree<N: ItemTreeNode>(id: ItemTreeId<N>, db: &dyn DefDatabase) -> Attrs {
+    let tree = db.item_tree(id.file_id);
+    let mod_item = N::id_to_mod_item(id.value);
+    tree.attrs(mod_item).clone()
 }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index f159f80af..3ced648e5 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -5,7 +5,7 @@ use either::Either;
 use hir_expand::{
     hygiene::Hygiene,
     name::{name, AsName, Name},
-    HirFileId, MacroDefId, MacroDefKind,
+    AstId, HirFileId, MacroDefId, MacroDefKind,
 };
 use ra_arena::Arena;
 use ra_syntax::{
@@ -27,6 +27,7 @@ use crate::{
         LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
     },
     item_scope::BuiltinShadowMode,
+    item_tree::{FileItemTreeId, ItemTree, ItemTreeNode},
     path::{GenericArgs, Path},
     type_ref::{Mutability, Rawness, TypeRef},
     AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
@@ -35,6 +36,8 @@ use crate::{
 
 use super::{ExprSource, PatSource};
 use ast::AstChildren;
+use rustc_hash::FxHashMap;
+use std::sync::Arc;
 
 pub(crate) struct LowerCtx {
     hygiene: Hygiene,
@@ -60,10 +63,10 @@ pub(super) fn lower(
     params: Option<ast::ParamList>,
     body: Option<ast::Expr>,
 ) -> (Body, BodySourceMap) {
+    let item_tree = db.item_tree(expander.current_file_id);
     ExprCollector {
         db,
         def,
-        expander,
         source_map: BodySourceMap::default(),
         body: Body {
             exprs: Arena::default(),
@@ -72,6 +75,12 @@ pub(super) fn lower(
             body_expr: dummy_expr_id(),
             item_scope: Default::default(),
         },
+        item_trees: {
+            let mut map = FxHashMap::default();
+            map.insert(expander.current_file_id, item_tree);
+            map
+        },
+        expander,
     }
     .collect(params, body)
 }
@@ -82,6 +91,8 @@ struct ExprCollector<'a> {
     expander: Expander,
     body: Body,
     source_map: BodySourceMap,
+
+    item_trees: FxHashMap<HirFileId, Arc<ItemTree>>,
 }
 
 impl ExprCollector<'_> {
@@ -533,6 +544,9 @@ impl ExprCollector<'_> {
                             self.source_map
                                 .expansions
                                 .insert(macro_call, self.expander.current_file_id);
+
+                            let item_tree = self.db.item_tree(self.expander.current_file_id);
+                            self.item_trees.insert(self.expander.current_file_id, item_tree);
                             let id = self.collect_expr(expansion);
                             self.expander.exit(self.db, mark);
                             id
@@ -547,6 +561,19 @@ impl ExprCollector<'_> {
         }
     }
 
+    fn find_inner_item<S: ItemTreeNode>(&self, id: AstId<ast::ModuleItem>) -> FileItemTreeId<S> {
+        let tree = &self.item_trees[&id.file_id];
+
+        // FIXME: This probably breaks with `use` items, since they produce multiple item tree nodes
+
+        // Root file (non-macro).
+        tree.all_inner_items()
+            .chain(tree.top_level_items().iter().copied())
+            .filter_map(|mod_item| mod_item.downcast::<S>())
+            .find(|tree_id| tree[*tree_id].ast_id().upcast() == id.value)
+            .unwrap_or_else(|| panic!("couldn't find inner item for {:?}", id))
+    }
+
     fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
         if let Some(expr) = expr {
             self.collect_expr(expr)
@@ -578,56 +605,102 @@ impl ExprCollector<'_> {
 
     fn collect_block_items(&mut self, block: &ast::BlockExpr) {
         let container = ContainerId::DefWithBodyId(self.def);
-        for item in block.items() {
-            let (def, name): (ModuleDefId, Option<ast::Name>) = match item {
-                ast::ModuleItem::FnDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (
-                        FunctionLoc { container: container.into(), ast_id }.intern(self.db).into(),
-                        def.name(),
-                    )
-                }
-                ast::ModuleItem::TypeAliasDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (
-                        TypeAliasLoc { container: container.into(), ast_id }.intern(self.db).into(),
-                        def.name(),
-                    )
-                }
-                ast::ModuleItem::ConstDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (
-                        ConstLoc { container: container.into(), ast_id }.intern(self.db).into(),
-                        def.name(),
-                    )
-                }
-                ast::ModuleItem::StaticDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (StaticLoc { container, ast_id }.intern(self.db).into(), def.name())
-                }
-                ast::ModuleItem::StructDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (StructLoc { container, ast_id }.intern(self.db).into(), def.name())
-                }
-                ast::ModuleItem::EnumDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (EnumLoc { container, ast_id }.intern(self.db).into(), def.name())
-                }
-                ast::ModuleItem::UnionDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (UnionLoc { container, ast_id }.intern(self.db).into(), def.name())
-                }
-                ast::ModuleItem::TraitDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (TraitLoc { container, ast_id }.intern(self.db).into(), def.name())
-                }
-                ast::ModuleItem::ExternBlock(_) => continue, // FIXME: collect from extern blocks
-                ast::ModuleItem::ImplDef(_)
-                | ast::ModuleItem::UseItem(_)
-                | ast::ModuleItem::ExternCrateItem(_)
-                | ast::ModuleItem::Module(_)
-                | ast::ModuleItem::MacroCall(_) => continue,
-            };
+
+        let items = block
+            .items()
+            .filter_map(|item| {
+                let (def, name): (ModuleDefId, Option<ast::Name>) = match item {
+                    ast::ModuleItem::FnDef(def) => {
+                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (
+                            FunctionLoc { container: container.into(), id: ast_id.with_value(id) }
+                                .intern(self.db)
+                                .into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::TypeAliasDef(def) => {
+                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (
+                            TypeAliasLoc { container: container.into(), id: ast_id.with_value(id) }
+                                .intern(self.db)
+                                .into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::ConstDef(def) => {
+                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (
+                            ConstLoc { container: container.into(), id: ast_id.with_value(id) }
+                                .intern(self.db)
+                                .into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::StaticDef(def) => {
+                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (
+                            StaticLoc { container, id: ast_id.with_value(id) }
+                                .intern(self.db)
+                                .into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::StructDef(def) => {
+                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (
+                            StructLoc { container, id: ast_id.with_value(id) }
+                                .intern(self.db)
+                                .into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::EnumDef(def) => {
+                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (
+                            EnumLoc { container, id: ast_id.with_value(id) }.intern(self.db).into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::UnionDef(def) => {
+                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (
+                            UnionLoc { container, id: ast_id.with_value(id) }
+                                .intern(self.db)
+                                .into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::TraitDef(def) => {
+                        let ast_id = self.expander.ast_id(&def);
+                        let id = self.find_inner_item(ast_id.map(|id| id.upcast()));
+                        (
+                            TraitLoc { container, id: ast_id.with_value(id) }
+                                .intern(self.db)
+                                .into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::ExternBlock(_) => return None, // FIXME: collect from extern blocks
+                    ast::ModuleItem::ImplDef(_)
+                    | ast::ModuleItem::UseItem(_)
+                    | ast::ModuleItem::ExternCrateItem(_)
+                    | ast::ModuleItem::Module(_)
+                    | ast::ModuleItem::MacroCall(_) => return None,
+                };
+
+                Some((def, name))
+            })
+            .collect::<Vec<_>>();
+
+        for (def, name) in items {
             self.body.item_scope.define_def(def);
             if let Some(name) = name {
                 let vis = crate::visibility::Visibility::Public; // FIXME determine correctly
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs
index e48ff38f9..81397b063 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -87,15 +87,13 @@ impl ExprScopes {
     }
 
     fn add_bindings(&mut self, body: &Body, scope: ScopeId, pat: PatId) {
-        match &body[pat] {
-            Pat::Bind { name, .. } => {
-                // bind can have a sub pattern, but it's actually not allowed
-                // to bind to things in there
-                let entry = ScopeEntry { name: name.clone(), pat };
-                self.scopes[scope].entries.push(entry)
-            }
-            p => p.walk_child_pats(|pat| self.add_bindings(body, scope, pat)),
+        let pattern = &body[pat];
+        if let Pat::Bind { name, .. } = pattern {
+            let entry = ScopeEntry { name: name.clone(), pat };
+            self.scopes[scope].entries.push(entry);
         }
+
+        pattern.walk_child_pats(|pat| self.add_bindings(body, scope, pat));
     }
 
     fn add_params_bindings(&mut self, body: &Body, scope: ScopeId, params: &[PatId]) {
@@ -190,21 +188,23 @@ mod tests {
         }
     }
 
-    fn do_check(code: &str, expected: &[&str]) {
-        let (off, code) = extract_offset(code);
+    fn do_check(ra_fixture: &str, expected: &[&str]) {
+        let (offset, code) = extract_offset(ra_fixture);
         let code = {
             let mut buf = String::new();
-            let off: usize = off.into();
+            let off: usize = offset.into();
             buf.push_str(&code[..off]);
-            buf.push_str("marker");
+            buf.push_str("<|>marker");
             buf.push_str(&code[off..]);
             buf
         };
 
-        let (db, file_id) = TestDB::with_single_file(&code);
+        let (db, position) = TestDB::with_position(&code);
+        let file_id = position.file_id;
+        let offset = position.offset;
 
         let file_syntax = db.parse(file_id).syntax_node();
-        let marker: ast::PathExpr = find_node_at_offset(&file_syntax, off).unwrap();
+        let marker: ast::PathExpr = find_node_at_offset(&file_syntax, offset).unwrap();
         let function = find_function(&db, file_id);
 
         let scopes = db.expr_scopes(function.into());
@@ -300,15 +300,52 @@ mod tests {
         );
     }
 
-    fn do_check_local_name(code: &str, expected_offset: u32) {
-        let (off, code) = extract_offset(code);
+    #[test]
+    fn test_bindings_after_at() {
+        do_check(
+            r"
+fn foo() {
+    match Some(()) {
+        opt @ Some(unit) => {
+            <|>
+        }
+        _ => {}
+    }
+}
+",
+            &["opt", "unit"],
+        );
+    }
+
+    #[test]
+    fn macro_inner_item() {
+        do_check(
+            r"
+            macro_rules! mac {
+                () => {{
+                    fn inner() {}
+                    inner();
+                }};
+            }
+
+            fn foo() {
+                mac!();
+                <|>
+            }
+        ",
+            &[],
+        );
+    }
 
-        let (db, file_id) = TestDB::with_single_file(&code);
+    fn do_check_local_name(ra_fixture: &str, expected_offset: u32) {
+        let (db, position) = TestDB::with_position(ra_fixture);
+        let file_id = position.file_id;
+        let offset = position.offset;
 
         let file = db.parse(file_id).ok().unwrap();
         let expected_name = find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into())
             .expect("failed to find a name at the target offset");
-        let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
+        let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), offset).unwrap();
 
         let function = find_function(&db, file_id);
 
@@ -336,15 +373,16 @@ mod tests {
     fn test_resolve_local_name() {
         do_check_local_name(
             r#"
-            fn foo(x: i32, y: u32) {
-                {
-                    let z = x * 2;
-                }
-                {
-                    let t = x<|> * 3;
-                }
-            }"#,
-            21,
+fn foo(x: i32, y: u32) {
+    {
+        let z = x * 2;
+    }
+    {
+        let t = x<|> * 3;
+    }
+}
+"#,
+            7,
         );
     }
 
@@ -352,10 +390,11 @@ mod tests {
     fn test_resolve_local_name_declaration() {
         do_check_local_name(
             r#"
-            fn foo(x: String) {
-                let x : &str = &x<|>;
-            }"#,
-            21,
+fn foo(x: String) {
+    let x : &str = &x<|>;
+}
+"#,
+            7,
         );
     }
 
@@ -363,12 +402,12 @@ mod tests {
     fn test_resolve_local_name_shadow() {
         do_check_local_name(
             r"
-            fn foo(x: String) {
-                let x : &str = &x;
-                x<|>
-            }
-            ",
-            53,
+fn foo(x: String) {
+    let x : &str = &x;
+    x<|>
+}
+",
+            28,
         );
     }
 
@@ -376,13 +415,13 @@ mod tests {
     fn ref_patterns_contribute_bindings() {
         do_check_local_name(
             r"
-            fn foo() {
-                if let Some(&from) = bar() {
-                    from<|>;
-                }
-            }
-            ",
-            53,
+fn foo() {
+    if let Some(&from) = bar() {
+        from<|>;
+    }
+}
+",
+            28,
         );
     }
 
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 53599e74a..f9e5701db 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -2,27 +2,19 @@
 
 use std::sync::Arc;
 
-use hir_expand::{
-    hygiene::Hygiene,
-    name::{name, AsName, Name},
-    AstId, InFile,
-};
+use hir_expand::{name::Name, InFile};
 use ra_prof::profile;
-use ra_syntax::ast::{
-    self, AssocItem, AstNode, ModuleItemOwner, NameOwner, TypeAscriptionOwner, TypeBoundsOwner,
-    VisibilityOwner,
-};
+use ra_syntax::ast;
 
 use crate::{
     attr::Attrs,
-    body::LowerCtx,
+    body::Expander,
     db::DefDatabase,
-    path::{path, AssociatedTypeBinding, GenericArgs, Path},
-    src::HasSource,
-    type_ref::{Mutability, TypeBound, TypeRef},
+    item_tree::{AssocItem, ItemTreeId, ModItem},
+    type_ref::{TypeBound, TypeRef},
     visibility::RawVisibility,
-    AssocContainerId, AssocItemId, ConstId, ConstLoc, Expander, FunctionId, FunctionLoc, HasModule,
-    ImplId, Intern, Lookup, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
+    AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
+    Intern, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -41,82 +33,27 @@ pub struct FunctionData {
 impl FunctionData {
     pub(crate) fn fn_data_query(db: &impl DefDatabase, func: FunctionId) -> Arc<FunctionData> {
         let loc = func.lookup(db);
-        let src = loc.source(db);
-        let ctx = LowerCtx::new(db, src.file_id);
-        let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
-        let mut params = Vec::new();
-        let mut has_self_param = false;
-        if let Some(param_list) = src.value.param_list() {
-            if let Some(self_param) = param_list.self_param() {
-                let self_type = if let Some(type_ref) = self_param.ascribed_type() {
-                    TypeRef::from_ast(&ctx, type_ref)
-                } else {
-                    let self_type = TypeRef::Path(name![Self].into());
-                    match self_param.kind() {
-                        ast::SelfParamKind::Owned => self_type,
-                        ast::SelfParamKind::Ref => {
-                            TypeRef::Reference(Box::new(self_type), Mutability::Shared)
-                        }
-                        ast::SelfParamKind::MutRef => {
-                            TypeRef::Reference(Box::new(self_type), Mutability::Mut)
-                        }
-                    }
-                };
-                params.push(self_type);
-                has_self_param = true;
-            }
-            for param in param_list.params() {
-                let type_ref = TypeRef::from_ast_opt(&ctx, param.ascribed_type());
-                params.push(type_ref);
-            }
-        }
-        let attrs = Attrs::new(&src.value, &Hygiene::new(db.upcast(), src.file_id));
-
-        let ret_type = if let Some(type_ref) = src.value.ret_type().and_then(|rt| rt.type_ref()) {
-            TypeRef::from_ast(&ctx, type_ref)
-        } else {
-            TypeRef::unit()
-        };
-
-        let ret_type = if src.value.async_token().is_some() {
-            let future_impl = desugar_future_path(ret_type);
-            let ty_bound = TypeBound::Path(future_impl);
-            TypeRef::ImplTrait(vec![ty_bound])
-        } else {
-            ret_type
-        };
-
-        let is_unsafe = src.value.unsafe_token().is_some();
-
-        let vis_default = RawVisibility::default_for_container(loc.container);
-        let visibility =
-            RawVisibility::from_ast_with_default(db, vis_default, src.map(|s| s.visibility()));
-
-        let sig =
-            FunctionData { name, params, ret_type, has_self_param, is_unsafe, visibility, attrs };
-        Arc::new(sig)
+        let item_tree = db.item_tree(loc.id.file_id);
+        let func = &item_tree[loc.id.value];
+
+        Arc::new(FunctionData {
+            name: func.name.clone(),
+            params: func.params.to_vec(),
+            ret_type: func.ret_type.clone(),
+            attrs: item_tree.attrs(loc.id.value.into()).clone(),
+            has_self_param: func.has_self_param,
+            is_unsafe: func.is_unsafe,
+            visibility: item_tree[func.visibility].clone(),
+        })
     }
 }
 
-fn desugar_future_path(orig: TypeRef) -> Path {
-    let path = path![core::future::Future];
-    let mut generic_args: Vec<_> = std::iter::repeat(None).take(path.segments.len() - 1).collect();
-    let mut last = GenericArgs::empty();
-    last.bindings.push(AssociatedTypeBinding {
-        name: name![Output],
-        type_ref: Some(orig),
-        bounds: Vec::new(),
-    });
-    generic_args.push(Some(Arc::new(last)));
-
-    Path::from_known_path(path, generic_args)
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]