48 files changed, 1349 insertions, 260 deletions
diff --git a/crates/ra_cargo_watch/Cargo.toml b/crates/ra_cargo_watch/Cargo.toml
index 731d50371..741345a21 100644
--- a/crates/ra_cargo_watch/Cargo.toml
+++ b/crates/ra_cargo_watch/Cargo.toml
@@ -6,10 +6,10 @@ authors = ["rust-analyzer developers"]
 [dependencies]
 crossbeam-channel = "0.4.0"
-lsp-types = { version = "0.72.0", features = ["proposed"] }
+lsp-types = { version = "0.73.0", features = ["proposed"] }
 log = "0.4.8"
 cargo_metadata = "0.9.1"
 serde_json = "1.0.48"
 [dev-dependencies]
-insta = "0.13.1"
+insta = "0.15.0"
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index da7af110c..947d6ad56 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -56,6 +56,7 @@ fn with_single_file(db: &mut dyn SourceDatabaseExt, text: &str) -> FileId {
    crate_graph.add_crate_root(
        file_id,
        Edition::Edition2018,
+        None,
        CfgOptions::default(),
        Env::default(),
    );
@@ -98,8 +99,13 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
        assert!(meta.path.starts_with(&source_root_prefix));
        if let Some(krate) = meta.krate {
-            let crate_id =
+            let crate_id = crate_graph.add_crate_root(
-                crate_graph.add_crate_root(file_id, meta.edition, meta.cfg, Env::default());
+                file_id,
+                meta.edition,
+                Some(krate.clone()),
+                meta.cfg,
+                Env::default(),
+            );
            let prev = crates.insert(krate.clone(), crate_id);
            assert!(prev.is_none());
            for dep in meta.deps {
@@ -132,6 +138,7 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
        crate_graph.add_crate_root(
            crate_root,
            Edition::Edition2018,
+            None,
            CfgOptions::default(),
            Env::default(),
        );
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index eaff99fd3..b77640b2b 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -6,7 +6,7 @@
 //! 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, str::FromStr};
+use std::{fmt, ops, str::FromStr};
 use ra_cfg::CfgOptions;
 use ra_syntax::SmolStr;
@@ -86,7 +86,7 @@ pub struct CrateId(pub u32);
 pub struct CrateName(SmolStr);
 impl CrateName {
-    /// Crates a crate name, checking for dashes in the string provided.
+    /// Creates a crate name, checking for dashes in the string provided.
    /// Dashes are not allowed in the crate names,
    /// hence the input string is returned as `Err` for those cases.
    pub fn new(name: &str) -> Result<CrateName, &str> {
@@ -97,19 +97,23 @@ impl CrateName {
        }
    }
-    /// Crates a crate name, unconditionally replacing the dashes with underscores.
+    /// Creates a crate name, unconditionally replacing the dashes with underscores.
    pub fn normalize_dashes(name: &str) -> CrateName {
        Self(SmolStr::new(name.replace('-', "_")))
    }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
-struct CrateData {
+pub struct CrateData {
-    file_id: FileId,
+    pub root_file_id: FileId,
-    edition: Edition,
+    pub edition: Edition,
-    cfg_options: CfgOptions,
+    /// The name to display to the end user.
-    env: Env,
+    /// This actual crate name can be different in a particular dependent crate
-    dependencies: Vec<Dependency>,
+    /// or may even be missing for some cases, such as a dummy crate for the code snippet.
+    pub display_name: Option<String>,
+    pub cfg_options: CfgOptions,
+    pub env: Env,
+    pub dependencies: Vec<Dependency>,
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -134,20 +138,24 @@ impl CrateGraph {
        &mut self,
        file_id: FileId,
        edition: Edition,
+        display_name: Option<String>,
        cfg_options: CfgOptions,
        env: Env,
    ) -> CrateId {
-        let data = CrateData::new(file_id, edition, cfg_options, env);
+        let data = CrateData {
+            root_file_id: file_id,
+            edition,
+            display_name,
+            cfg_options,
+            env,
+            dependencies: Vec::new(),
+        };
        let crate_id = CrateId(self.arena.len() as u32);
        let prev = self.arena.insert(crate_id, data);
        assert!(prev.is_none());
        crate_id
    }
-    pub fn cfg_options(&self, crate_id: CrateId) -> &CfgOptions {
-        &self.arena[&crate_id].cfg_options
-    }
    pub fn add_dep(
        &mut self,
        from: CrateId,
@@ -169,24 +177,13 @@ impl CrateGraph {
        self.arena.keys().copied()
    }
-    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
-        self.arena[&crate_id].file_id
-    }
-    pub fn edition(&self, crate_id: CrateId) -> Edition {
-        self.arena[&crate_id].edition
-    }
    // FIXME: this only finds one crate with the given root; we could have multiple
    pub fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
-        let (&crate_id, _) = self.arena.iter().find(|(_crate_id, data)| data.file_id == file_id)?;
+        let (&crate_id, _) =
+            self.arena.iter().find(|(_crate_id, data)| data.root_file_id == file_id)?;
        Some(crate_id)
    }
-    pub fn dependencies(&self, crate_id: CrateId) -> impl Iterator<Item = &Dependency> {
-        self.arena[&crate_id].dependencies.iter()
-    }
    /// Extends this crate graph by adding a complete disjoint second crate
    /// graph.
    ///
@@ -209,8 +206,8 @@ impl CrateGraph {
            return false;
        }
-        for dep in self.dependencies(from) {
+        for dep in &self[from].dependencies {
-            let crate_id = dep.crate_id();
+            let crate_id = dep.crate_id;
            if crate_id == target {
                return true;
            }
@@ -223,6 +220,13 @@ impl CrateGraph {
    }
 }
+impl ops::Index<CrateId> for CrateGraph {
+    type Output = CrateData;
+    fn index(&self, crate_id: CrateId) -> &CrateData {
+        &self.arena[&crate_id]
+    }
+}
 impl CrateId {
    pub fn shift(self, amount: u32) -> CrateId {
        CrateId(self.0 + amount)
@@ -230,10 +234,6 @@ impl CrateId {
 }
 impl CrateData {
-    fn new(file_id: FileId, edition: Edition, cfg_options: CfgOptions, env: Env) -> CrateData {
-        CrateData { file_id, edition, dependencies: Vec::new(), cfg_options, env }
-    }
    fn add_dep(&mut self, name: SmolStr, crate_id: CrateId) {
        self.dependencies.push(Dependency { name, crate_id })
    }
@@ -261,12 +261,6 @@ impl fmt::Display for Edition {
    }
 }
-impl Dependency {
-    pub fn crate_id(&self) -> CrateId {
-        self.crate_id
-    }
-}
 #[derive(Debug)]
 pub struct ParseEditionError {
    invalid_input: String,
@@ -290,12 +284,27 @@ mod tests {
    #[test]
    fn it_should_panic_because_of_cycle_dependencies() {
        let mut graph = CrateGraph::default();
-        let crate1 =
+        let crate1 = graph.add_crate_root(
-            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
+            FileId(1u32),
-        let crate2 =
+            Edition2018,
-            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+            None,
-        let crate3 =
+            CfgOptions::default(),
-            graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default(), Env::default());
+            Env::default(),
+        );
+        let crate2 = graph.add_crate_root(
+            FileId(2u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+        );
+        let crate3 = graph.add_crate_root(
+            FileId(3u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::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());
        assert!(graph.add_dep(crate3, CrateName::new("crate1").unwrap(), crate1).is_err());
@@ -304,12 +313,27 @@ mod tests {
    #[test]
    fn it_works() {
        let mut graph = CrateGraph::default();
-        let crate1 =
+        let crate1 = graph.add_crate_root(
-            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
+            FileId(1u32),
-        let crate2 =
+            Edition2018,
-            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+            None,
-        let crate3 =
+            CfgOptions::default(),
-            graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default(), Env::default());
+            Env::default(),
+        );
+        let crate2 = graph.add_crate_root(
+            FileId(2u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+        );
+        let crate3 = graph.add_crate_root(
+            FileId(3u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::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());
    }
@@ -317,16 +341,26 @@ mod tests {
    #[test]
    fn dashes_are_normalized() {
        let mut graph = CrateGraph::default();
-        let crate1 =
+        let crate1 = graph.add_crate_root(
-            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
+            FileId(1u32),
-        let crate2 =
+            Edition2018,
-            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+            None,
+            CfgOptions::default(),
+            Env::default(),
+        );
+        let crate2 = graph.add_crate_root(
+            FileId(2u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+        );
        assert!(graph
            .add_dep(crate1, CrateName::normalize_dashes("crate-name-with-dashes"), crate2)
            .is_ok());
        assert_eq!(
-            graph.dependencies(crate1).collect::<Vec<_>>(),
+            graph[crate1].dependencies,
-            vec![&Dependency { crate_id: crate2, name: "crate_name_with_dashes".into() }]
+            vec![Dependency { crate_id: crate2, name: "crate_name_with_dashes".into() }]
        );
    }
 }
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 0555a0de7..266c4cff3 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -12,6 +12,8 @@ log = "0.4.8"
 rustc-hash = "1.1.0"
 either = "1.5.3"
+itertools = "0.8.2"
 ra_syntax = { path = "../ra_syntax" }
 ra_db = { path = "../ra_db" }
 ra_prof = { path = "../ra_prof" }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 2944926e6..41d4e2ed3 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -54,10 +54,11 @@ pub struct CrateDependency {
 impl Crate {
    pub fn dependencies(self, db: &impl DefDatabase) -> Vec<CrateDependency> {
-        db.crate_graph()
+        db.crate_graph()[self.id]
-            .dependencies(self.id)
+            .dependencies
+            .iter()
            .map(|dep| {
-                let krate = Crate { id: dep.crate_id() };
+                let krate = Crate { id: dep.crate_id };
                let name = dep.as_name();
                CrateDependency { krate, name }
            })
@@ -69,7 +70,9 @@ impl Crate {
        let crate_graph = db.crate_graph();
        crate_graph
            .iter()
-            .filter(|&krate| crate_graph.dependencies(krate).any(|it| it.crate_id == self.id))
+            .filter(|&krate| {
+                crate_graph[krate].dependencies.iter().any(|it| it.crate_id == self.id)
+            })
            .map(|id| Crate { id })
            .collect()
    }
@@ -80,12 +83,11 @@ impl Crate {
    }
    pub fn root_file(self, db: &impl DefDatabase) -> FileId {
-        db.crate_graph().crate_root(self.id)
+        db.crate_graph()[self.id].root_file_id
    }
    pub fn edition(self, db: &impl DefDatabase) -> Edition {
-        let crate_graph = db.crate_graph();
+        db.crate_graph()[self.id].edition
-        crate_graph.edition(self.id)
    }
    pub fn all(db: &impl DefDatabase) -> Vec<Crate> {
@@ -204,10 +206,26 @@ impl Module {
    }
    /// Returns a `ModuleScope`: a set of items, visible in this module.
-    pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef)> {
+    pub fn scope(
+        self,
+        db: &impl HirDatabase,
+        visible_from: Option<Module>,
+    ) -> Vec<(Name, ScopeDef)> {
        db.crate_def_map(self.id.krate)[self.id.local_id]
            .scope
            .entries()
+            .filter_map(|(name, def)| {
+                if let Some(m) = visible_from {
+                    let filtered = def.filter_visibility(|vis| vis.is_visible_from(db, m.id));
+                    if filtered.is_none() && !def.is_none() {
+                        None
+                    } else {
+                        Some((name, filtered))
+                    }
+                } else {
+                    Some((name, def))
+                }
+            })
            .map(|(name, def)| (name.clone(), def.into()))
            .collect()
    }
@@ -480,6 +498,14 @@ impl Adt {
    pub fn krate(self, db: &impl HirDatabase) -> Option<Crate> {
        Some(self.module(db).krate())
    }
+    pub fn name(&self, db: &impl HirDatabase) -> Name {
+        match self {
+            Adt::Struct(s) => s.name(db),
+            Adt::Union(u) => u.name(db),
+            Adt::Enum(e) => e.name(db),
+        }
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -507,6 +533,14 @@ impl VariantDef {
        }
    }
+    pub fn name(&self, db: &impl HirDatabase) -> Name {
+        match self {
+            VariantDef::Struct(s) => s.name(db),
+            VariantDef::Union(u) => u.name(db),
+            VariantDef::EnumVariant(e) => e.name(db),
+        }
+    }
    pub(crate) fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
        match self {
            VariantDef::Struct(it) => it.variant_data(db),
@@ -534,6 +568,14 @@ impl DefWithBody {
            DefWithBody::Static(s) => s.module(db),
        }
    }
+    pub fn name(self, db: &impl HirDatabase) -> Option<Name> {
+        match self {
+            DefWithBody::Function(f) => Some(f.name(db)),
+            DefWithBody::Static(s) => s.name(db),
+            DefWithBody::Const(c) => c.name(db),
+        }
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -571,6 +613,14 @@ impl Function {
    }
 }
+impl HasVisibility for Function {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility {
+        let function_data = db.function_data(self.id);
+        let visibility = &function_data.visibility;
+        visibility.resolve(db, &self.id.resolver(db))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Const {
    pub(crate) id: ConstId,
@@ -590,6 +640,14 @@ impl Const {
    }
 }
+impl HasVisibility for Const {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility {
+        let function_data = db.const_data(self.id);
+        let visibility = &function_data.visibility;
+        visibility.resolve(db, &self.id.resolver(db))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Static {
    pub(crate) id: StaticId,
@@ -664,6 +722,14 @@ impl TypeAlias {
    }
 }
+impl HasVisibility for TypeAlias {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility {
+        let function_data = db.type_alias_data(self.id);
+        let visibility = &function_data.visibility;
+        visibility.resolve(db, &self.id.resolver(db))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct MacroDef {
    pub(crate) id: MacroDefId,
@@ -751,6 +817,16 @@ impl AssocItem {
    }
 }
+impl HasVisibility for AssocItem {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility {
+        match self {
+            AssocItem::Function(f) => f.visibility(db),
+            AssocItem::Const(c) => c.visibility(db),
+            AssocItem::TypeAlias(t) => t.visibility(db),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
 pub enum GenericDef {
    Function(Function),
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 965d185a4..3782a9984 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -6,7 +6,7 @@ use std::{cell::RefCell, fmt, iter::successors};
 use hir_def::{
    resolver::{self, HasResolver, Resolver},
-    TraitId,
+    AsMacroCall, TraitId,
 };
 use hir_expand::ExpansionInfo;
 use ra_db::{FileId, FileRange};
@@ -70,6 +70,20 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        Some(node)
    }
+    pub fn expand_hypothetical(
+        &self,
+        actual_macro_call: &ast::MacroCall,
+        hypothetical_args: &ast::TokenTree,
+        token_to_map: SyntaxToken,
+    ) -> Option<(SyntaxNode, SyntaxToken)> {
+        let macro_call =
+            self.find_file(actual_macro_call.syntax().clone()).with_value(actual_macro_call);
+        let sa = self.analyze2(macro_call.map(|it| it.syntax()), None);
+        let macro_call_id = macro_call
+            .as_call_id(self.db, |path| sa.resolver.resolve_path_as_macro(self.db, &path))?;
+        hir_expand::db::expand_hypothetical(self.db, macro_call_id, hypothetical_args, token_to_map)
+    }
    pub fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
        let parent = token.parent();
        let parent = self.find_file(parent);
@@ -104,6 +118,25 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        node.ancestors_with_macros(self.db).map(|it| it.value)
    }
+    pub fn ancestors_at_offset_with_macros(
+        &self,
+        node: &SyntaxNode,
+        offset: TextUnit,
+    ) -> impl Iterator<Item = SyntaxNode> + '_ {
+        use itertools::Itertools;
+        node.token_at_offset(offset)
+            .map(|token| self.ancestors_with_macros(token.parent()))
+            .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
+    }
+    pub fn find_node_at_offset_with_macros<N: AstNode>(
+        &self,
+        node: &SyntaxNode,
+        offset: TextUnit,
+    ) -> Option<N> {
+        self.ancestors_at_offset_with_macros(node, offset).find_map(N::cast)
+    }
    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
        self.analyze(expr.syntax()).type_of(self.db, &expr)
    }
diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index fa25cc4fb..30a12337e 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -26,4 +26,4 @@ ra_cfg = { path = "../ra_cfg" }
 tt = { path = "../ra_tt", package = "ra_tt" }
 [dev-dependencies]
-insta = "0.13.1"
+insta = "0.15.0"
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 9fc43f3fb..a72eb5369 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -7,13 +7,16 @@ use hir_expand::{
    AstId, InFile,
 };
 use ra_prof::profile;
-use ra_syntax::ast::{self, AstNode, ImplItem, ModuleItemOwner, NameOwner, TypeAscriptionOwner};
+use ra_syntax::ast::{
+    self, AstNode, ImplItem, ModuleItemOwner, NameOwner, TypeAscriptionOwner, VisibilityOwner,
+};
 use crate::{
    db::DefDatabase,
    path::{path, GenericArgs, Path},
    src::HasSource,
    type_ref::{Mutability, TypeBound, TypeRef},
+    visibility::RawVisibility,
    AssocContainerId, AssocItemId, ConstId, ConstLoc, Expander, FunctionId, FunctionLoc, HasModule,
    ImplId, Intern, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
 };
@@ -26,6 +29,7 @@ pub struct FunctionData {
    /// True if the first param is `self`. This is relevant to decide whether this
    /// can be called as a method.
    pub has_self_param: bool,
+    pub visibility: RawVisibility,
 }
 impl FunctionData {
@@ -72,7 +76,9 @@ impl FunctionData {
            ret_type
        };
-        let sig = FunctionData { name, params, ret_type, has_self_param };
+        let visibility = RawVisibility::from_ast(db, src.map(|s| s.visibility()));
+        let sig = FunctionData { name, params, ret_type, has_self_param, visibility };
        Arc::new(sig)
    }
 }
@@ -91,6 +97,7 @@ fn desugar_future_path(orig: TypeRef) -> Path {
 pub struct TypeAliasData {
    pub name: Name,
    pub type_ref: Option<TypeRef>,
+    pub visibility: RawVisibility,
 }
 impl TypeAliasData {
@@ -98,10 +105,11 @@ impl TypeAliasData {
        db: &impl DefDatabase,
        typ: TypeAliasId,
    ) -> Arc<TypeAliasData> {
-        let node = typ.lookup(db).source(db).value;
+        let node = typ.lookup(db).source(db);
-        let name = node.name().map_or_else(Name::missing, |n| n.as_name());
+        let name = node.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let type_ref = node.type_ref().map(TypeRef::from_ast);
+        let type_ref = node.value.type_ref().map(TypeRef::from_ast);
-        Arc::new(TypeAliasData { name, type_ref })
+        let visibility = RawVisibility::from_ast(db, node.map(|n| n.visibility()));
+        Arc::new(TypeAliasData { name, type_ref, visibility })
    }
 }
@@ -217,23 +225,28 @@ pub struct ConstData {
    /// const _: () = ();
    pub name: Option<Name>,
    pub type_ref: TypeRef,
+    pub visibility: RawVisibility,
 }
 impl ConstData {
    pub(crate) fn const_data_query(db: &impl DefDatabase, konst: ConstId) -> Arc<ConstData> {
-        let node = konst.lookup(db).source(db).value;
+        let node = konst.lookup(db).source(db);
-        Arc::new(ConstData::new(&node))
+        Arc::new(ConstData::new(db, node))
    }
    pub(crate) fn static_data_query(db: &impl DefDatabase, konst: StaticId) -> Arc<ConstData> {
-        let node = konst.lookup(db).source(db).value;
+        let node = konst.lookup(db).source(db);
-        Arc::new(ConstData::new(&node))
+        Arc::new(ConstData::new(db, node))
    }
-    fn new<N: NameOwner + TypeAscriptionOwner>(node: &N) -> ConstData {
+    fn new<N: NameOwner + TypeAscriptionOwner + VisibilityOwner>(
-        let name = node.name().map(|n| n.as_name());
+        db: &impl DefDatabase,
-        let type_ref = TypeRef::from_ast_opt(node.ascribed_type());
+        node: InFile<N>,
-        ConstData { name, type_ref }
+    ) -> ConstData {
+        let name = node.value.name().map(|n| n.as_name());
+        let type_ref = TypeRef::from_ast_opt(node.value.ascribed_type());
+        let visibility = RawVisibility::from_ast(db, node.map(|n| n.visibility()));
+        ConstData { name, type_ref, visibility }
    }
 }
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index 43b9b124a..07ca74ec3 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -176,7 +176,7 @@ fn find_importable_locations(
    // directly (only through reexports in direct dependencies).
    for krate in Some(from.krate)
        .into_iter()
-        .chain(crate_graph.dependencies(from.krate).map(|dep| dep.crate_id))
+        .chain(crate_graph[from.krate].dependencies.iter().map(|dep| dep.crate_id))
    {
        result.extend(
            importable_locations_in_crate(db, item, krate)
diff --git a/crates/ra_hir_def/src/lang_item.rs b/crates/ra_hir_def/src/lang_item.rs
index 5a336ea1f..6de49730e 100644
--- a/crates/ra_hir_def/src/lang_item.rs
+++ b/crates/ra_hir_def/src/lang_item.rs
@@ -116,8 +116,9 @@ impl LangItems {
        if let Some(target) = start_crate_target {
            return Some(*target);
        }
-        db.crate_graph()
+        db.crate_graph()[start_crate]
-            .dependencies(start_crate)
+            .dependencies
+            .iter()
            .find_map(|dep| db.lang_item(dep.crate_id, item.clone()))
    }
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 628c44c99..81eac52ad 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -177,10 +177,10 @@ pub struct ModuleData {
 impl CrateDefMap {
    pub(crate) fn crate_def_map_query(db: &impl DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
-        let _p = profile("crate_def_map_query");
+        let _p = profile("crate_def_map_query")
+            .detail(|| db.crate_graph()[krate].display_name.clone().unwrap_or_default());
        let def_map = {
-            let crate_graph = db.crate_graph();
+            let edition = db.crate_graph()[krate].edition;
-            let edition = crate_graph.edition(krate);
            let mut modules: Arena<LocalModuleId, ModuleData> = Arena::default();
            let root = modules.alloc(ModuleData::default());
            CrateDefMap {
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 51c65a5d7..d0459d9b0 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -34,7 +34,7 @@ pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> C
    let crate_graph = db.crate_graph();
    // populate external prelude
-    for dep in crate_graph.dependencies(def_map.krate) {
+    for dep in &crate_graph[def_map.krate].dependencies {
        let dep_def_map = db.crate_def_map(dep.crate_id);
        log::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
        def_map.extern_prelude.insert(
@@ -51,7 +51,7 @@ pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> C
        }
    }
-    let cfg_options = crate_graph.cfg_options(def_map.krate);
+    let cfg_options = &crate_graph[def_map.krate].cfg_options;
    let mut collector = DefCollector {
        db,
@@ -128,8 +128,7 @@ where
    DB: DefDatabase,
 {
    fn collect(&mut self) {
-        let crate_graph = self.db.crate_graph();
+        let file_id = self.db.crate_graph()[self.def_map.krate].root_file_id;
-        let file_id = crate_graph.crate_root(self.def_map.krate);
        let raw_items = self.db.raw_items(file_id.into());
        let module_id = self.def_map.root;
        self.def_map.modules[module_id].origin = ModuleOrigin::CrateRoot { definition: file_id };
@@ -955,7 +954,7 @@ mod tests {
        let krate = db.test_crate();
        let def_map = {
-            let edition = db.crate_graph().edition(krate);
+            let edition = db.crate_graph()[krate].edition;
            let mut modules: Arena<LocalModuleId, ModuleData> = Arena::default();
            let root = modules.alloc(ModuleData::default());
            CrateDefMap {
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index 9fc33e4b1..3f60b1cca 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -7,6 +7,7 @@ use crate::{
 use crate::{quote, EagerMacroId, LazyMacroId, MacroCallId};
 use either::Either;
+use mbe::parse_to_token_tree;
 use ra_db::{FileId, RelativePath};
 use ra_parser::FragmentKind;
@@ -142,7 +143,10 @@ fn env_expand(
    _tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
    // dummy implementation for type-checking purposes
-    let expanded = quote! { "" };
+    // we cannot use an empty string here, because for
+    // `include!(concat!(env!("OUT_DIR"), "/foo.rs"))` will become
+    // `include!("foo.rs"), which maybe infinite loop
+    let expanded = quote! { "__RA_UNIMPLEMENTATED__" };
    Ok(expanded)
 }
@@ -276,7 +280,12 @@ fn relative_file(db: &dyn AstDatabase, call_id: MacroCallId, path: &str) -> Opti
    let call_site = call_id.as_file().original_file(db);
    let path = RelativePath::new(&path);
-    db.resolve_relative_path(call_site, &path)
+    let res = db.resolve_relative_path(call_site, &path)?;
+    // Prevent include itself
+    if res == call_site {
+        return None;
+    }
+    Some(res)
 }
 fn include_expand(
@@ -298,10 +307,9 @@ fn include_expand(
    // FIXME:
    // Handle include as expression
-    let node =
+    let res = parse_to_token_tree(&db.file_text(file_id.into()))
-        db.parse_or_expand(file_id.into()).ok_or_else(|| mbe::ExpandError::ConversionError)?;
+        .ok_or_else(|| mbe::ExpandError::ConversionError)?
-    let res =
+        .0;
-        mbe::syntax_node_to_token_tree(&node).ok_or_else(|| mbe::ExpandError::ConversionError)?.0;
    Ok((res, FragmentKind::Items))
 }
@@ -394,7 +402,7 @@ mod tests {
            "#,
        );
-        assert_eq!(expanded, "\"\"");
+        assert_eq!(expanded, "\"__RA_UNIMPLEMENTATED__\"");
    }
    #[test]
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index f3a84cacc..29dde3d80 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -72,6 +72,30 @@ pub trait AstDatabase: SourceDatabase {
    fn intern_eager_expansion(&self, eager: EagerCallLoc) -> EagerMacroId;
 }
+/// This expands the given macro call, but with different arguments. This is
+/// used for completion, where we want to see what 'would happen' if we insert a
+/// token. The `token_to_map` mapped down into the expansion, with the mapped
+/// token returned.
+pub fn expand_hypothetical(
+    db: &impl AstDatabase,
+    actual_macro_call: MacroCallId,
+    hypothetical_args: &ra_syntax::ast::TokenTree,
+    token_to_map: ra_syntax::SyntaxToken,
+) -> Option<(SyntaxNode, ra_syntax::SyntaxToken)> {
+    let macro_file = MacroFile { macro_call_id: actual_macro_call };
+    let (tt, tmap_1) = mbe::syntax_node_to_token_tree(hypothetical_args.syntax()).unwrap();
+    let range =
+        token_to_map.text_range().checked_sub(hypothetical_args.syntax().text_range().start())?;
+    let token_id = tmap_1.token_by_range(range)?;
+    let macro_def = expander(db, actual_macro_call)?;
+    let (node, tmap_2) =
+        parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1))))?;
+    let token_id = macro_def.0.map_id_down(token_id);
+    let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
+    let token = ra_syntax::algo::find_covering_element(&node.syntax_node(), range).into_token()?;
+    Some((node.syntax_node(), token))
+}
 pub(crate) fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
    let map =
        db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it));
@@ -130,15 +154,42 @@ pub(crate) fn macro_expand(
    db: &dyn AstDatabase,
    id: MacroCallId,
 ) -> Result<Arc<tt::Subtree>, String> {
+    macro_expand_with_arg(db, id, None)
+}
+fn expander(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
+    let lazy_id = match id {
+        MacroCallId::LazyMacro(id) => id,
+        MacroCallId::EagerMacro(_id) => {
+            return None;
+        }
+    };
+    let loc = db.lookup_intern_macro(lazy_id);
+    let macro_rules = db.macro_def(loc.def)?;
+    Some(macro_rules)
+}
+fn macro_expand_with_arg(
+    db: &dyn AstDatabase,
+    id: MacroCallId,
+    arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
+) -> Result<Arc<tt::Subtree>, String> {
    let lazy_id = match id {
        MacroCallId::LazyMacro(id) => id,
        MacroCallId::EagerMacro(id) => {
-            return Ok(db.lookup_intern_eager_expansion(id).subtree);
+            if arg.is_some() {
+                return Err(
+                    "hypothetical macro expansion not implemented for eager macro".to_owned()
+                );
+            } else {
+                return Ok(db.lookup_intern_eager_expansion(id).subtree);
+            }
        }
    };
    let loc = db.lookup_intern_macro(lazy_id);
-    let macro_arg = db.macro_arg(id).ok_or("Fail to args in to tt::TokenTree")?;
+    let macro_arg = arg.or_else(|| db.macro_arg(id)).ok_or("Fail to args in to tt::TokenTree")?;
    let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?;
    let tt = macro_rules.0.expand(db, lazy_id, &macro_arg.0).map_err(|err| format!("{:?}", err))?;
@@ -163,11 +214,23 @@ pub(crate) fn parse_macro(
    db: &dyn AstDatabase,
    macro_file: MacroFile,
 ) -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)> {
+    parse_macro_with_arg(db, macro_file, None)
+}
+pub fn parse_macro_with_arg(
+    db: &dyn AstDatabase,
+    macro_file: MacroFile,
+    arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
+) -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)> {
    let _p = profile("parse_macro_query");
    let macro_call_id = macro_file.macro_call_id;
-    let tt = db
+    let expansion = if let Some(arg) = arg {
-        .macro_expand(macro_call_id)
+        macro_expand_with_arg(db, macro_call_id, Some(arg))
+    } else {
+        db.macro_expand(macro_call_id)
+    };
+    let tt = expansion
        .map_err(|err| {
            // Note:
            // The final goal we would like to make all parse_macro success,
diff --git a/crates/ra_hir_ty/Cargo.toml b/crates/ra_hir_ty/Cargo.toml
index f2558b579..9962112db 100644
--- a/crates/ra_hir_ty/Cargo.toml
+++ b/crates/ra_hir_ty/Cargo.toml
@@ -26,4 +26,4 @@ chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "177d713
 chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "177d71340acc7a7204a33115fc63075d86452179" }
 [dev-dependencies]
-insta = "0.13.1"
+insta = "0.15.0"
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index 42814941f..ffa78b046 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -484,6 +484,51 @@ fn bar() -> u32 {0}
 }
 #[test]
+fn infer_builtin_macros_include_concat_with_bad_env_should_failed() {
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs 
+#[rustc_builtin_macro]
+macro_rules! include {() => {}}
+#[rustc_builtin_macro]
+macro_rules! concat {() => {}}
+#[rustc_builtin_macro]
+macro_rules! env {() => {}}
+include!(concat!(env!("OUT_DIR"), "/foo.rs"));
+fn main() {
+    bar()<|>;
+}
+//- /foo.rs
+fn bar() -> u32 {0}
+"#,
+    );
+    assert_eq!("{unknown}", type_at_pos(&db, pos));
+}
+#[test]
+fn infer_builtin_macros_include_itself_should_failed() {
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs 
+#[rustc_builtin_macro]
+macro_rules! include {() => {}}
+include!("main.rs");
+fn main() {
+    0<|>
+}
+"#,
+    );
+    assert_eq!("i32", type_at_pos(&db, pos));
+}
+#[test]
 fn infer_builtin_macros_concat_with_lazy() {
    assert_snapshot!(
        infer(r#"
diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index 8de588790..6e1c8e42a 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -47,7 +47,7 @@ pub(crate) fn impls_for_trait_query(
    // will only ever get called for a few crates near the root of the tree (the
    // ones the user is editing), so this may actually be a waste of memory. I'm
    // doing it like this mainly for simplicity for now.
-    for dep in db.crate_graph().dependencies(krate) {
+    for dep in &db.crate_graph()[krate].dependencies {
        impls.extend(db.impls_for_trait(dep.crate_id, trait_).iter());
    }
    let crate_impl_defs = db.impls_in_crate(krate);
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index 410d8de62..7235c944c 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -35,4 +35,4 @@ ra_assists = { path = "../ra_assists" }
 hir = { path = "../ra_hir", package = "ra_hir" }
 [dev-dependencies]
-insta = "0.13.1"
+insta = "0.15.0"
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 9145aa183..f275305e2 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -38,7 +38,7 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
 fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
    for receiver in receiver.autoderef(ctx.db) {
        for (field, ty) in receiver.fields(ctx.db) {
-            if ctx.module.map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
+            if ctx.scope().module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
                // Skip private field. FIXME: If the definition location of the
                // field is editable, we should show the completion
                continue;
@@ -53,11 +53,14 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Ty
 }
 fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
-    if let Some(krate) = ctx.module.map(|it| it.krate()) {
+    if let Some(krate) = ctx.krate {
        let mut seen_methods = FxHashSet::default();
        let traits_in_scope = ctx.scope().traits_in_scope();
        receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
-            if func.has_self_param(ctx.db) && seen_methods.insert(func.name(ctx.db)) {
+            if func.has_self_param(ctx.db)
+                && ctx.scope().module().map_or(true, |m| func.is_visible_from(ctx.db, m))
+                && seen_methods.insert(func.name(ctx.db))
+            {
                acc.add_function(ctx, func);
            }
            None::<()>
@@ -308,6 +311,39 @@ mod tests {
    }
    #[test]
+    fn test_method_completion_private() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+            struct A {}
+            mod m {
+                impl super::A {
+                    fn private_method(&self) {}
+                    pub(super) fn the_method(&self) {}
+                }
+            }
+            fn foo(a: A) {
+               a.<|>
+            }
+            ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [256; 256),
+                delete: [256; 256),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "pub(super) fn the_method(&self)",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn test_trait_method_completion() {
        assert_debug_snapshot!(
            do_ref_completion(
@@ -584,4 +620,102 @@ mod tests {
        "###
        );
    }
+    #[test]
+    fn works_in_simple_macro_1() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                struct A { the_field: u32 }
+                fn foo(a: A) {
+                    m!(a.x<|>)
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [156; 157),
+                delete: [156; 157),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn works_in_simple_macro_recursive() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                struct A { the_field: u32 }
+                fn foo(a: A) {
+                    m!(a.x<|>)
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [156; 157),
+                delete: [156; 157),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn works_in_simple_macro_2() {
+        // this doesn't work yet because the macro doesn't expand without the token -- maybe it can be fixed with better recovery
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                struct A { the_field: u32 }
+                fn foo(a: A) {
+                    m!(a.<|>)
+                }
+                ",
+            ),
+            @r###"[]"###
+        );
+    }
+    #[test]
+    fn works_in_simple_macro_recursive_1() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                struct A { the_field: u32 }
+                fn foo(a: A) {
+                    m!(m!(m!(a.x<|>)))
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [162; 163),
+                delete: [162; 163),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
index eb7cd9ac2..e1c0ffb1f 100644
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -79,6 +79,7 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
 }
 fn is_in_loop_body(leaf: &SyntaxToken) -> bool {
+    // FIXME move this to CompletionContext and make it handle macros
    for node in leaf.parent().ancestors() {
        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
            break;
diff --git a/crates/ra_ide/src/completion/complete_path.rs b/crates/ra_ide/src/completion/complete_path.rs
index 1a9699466..3c4a70561 100644
--- a/crates/ra_ide/src/completion/complete_path.rs
+++ b/crates/ra_ide/src/completion/complete_path.rs
@@ -1,6 +1,6 @@
-//! Completion of paths, including when writing a single name.
+//! Completion of paths, i.e. `some::prefix::<|>`.
-use hir::{Adt, PathResolution, ScopeDef};
+use hir::{Adt, HasVisibility, PathResolution, ScopeDef};
 use ra_syntax::AstNode;
 use test_utils::tested_by;
@@ -15,9 +15,10 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
        Some(PathResolution::Def(def)) => def,
        _ => return,
    };
+    let context_module = ctx.scope().module();
    match def {
        hir::ModuleDef::Module(module) => {
-            let module_scope = module.scope(ctx.db);
+            let module_scope = module.scope(ctx.db, context_module);
            for (name, def) in module_scope {
                if ctx.use_item_syntax.is_some() {
                    if let ScopeDef::Unknown = def {
@@ -47,10 +48,13 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
            };
            // Iterate assoc types separately
            // FIXME: complete T::AssocType
-            let krate = ctx.module.map(|m| m.krate());
+            let krate = ctx.krate;
            if let Some(krate) = krate {
                let traits_in_scope = ctx.scope().traits_in_scope();
                ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
+                    if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
+                        return None;
+                    }
                    match item {
                        hir::AssocItem::Function(func) => {
                            if !func.has_self_param(ctx.db) {
@@ -64,6 +68,9 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
                });
                ty.iterate_impl_items(ctx.db, krate, |item| {
+                    if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
+                        return None;
+                    }
                    match item {
                        hir::AssocItem::Function(_) | hir::AssocItem::Const(_) => {}
                        hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
@@ -74,6 +81,9 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
        }
        hir::ModuleDef::Trait(t) => {
            for item in t.items(ctx.db) {
+                if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
+                    continue;
+                }
                match item {
                    hir::AssocItem::Function(func) => {
                        if !func.has_self_param(ctx.db) {
@@ -170,6 +180,41 @@ mod tests {
    }
    #[test]
+    fn path_visibility() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                use self::my::<|>;
+                mod my {
+                    struct Bar;
+                    pub struct Foo;
+                    pub use Bar as PublicBar;
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Foo",
+                source_range: [31; 31),
+                delete: [31; 31),
+                insert: "Foo",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "PublicBar",
+                source_range: [31; 31),
+                delete: [31; 31),
+                insert: "PublicBar",
+                kind: Struct,
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn completes_use_item_starting_with_self() {
        assert_debug_snapshot!(
            do_reference_completion(
@@ -177,7 +222,7 @@ mod tests {
                use self::m::<|>;
                mod m {
-                    struct Bar;
+                    pub struct Bar;
                }
                "
            ),
@@ -502,6 +547,60 @@ mod tests {
    }
    #[test]
+    fn associated_item_visibility() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                struct S;
+                mod m {
+                    impl super::S {
+                        pub(super) fn public_method() { }
+                        fn private_method() { }
+                        pub(super) type PublicType = u32;
+                        type PrivateType = u32;
+                        pub(super) const PUBLIC_CONST: u32 = 1;
+                        const PRIVATE_CONST: u32 = 1;
+                    }
+                }
+                fn foo() { let _ = S::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "PUBLIC_CONST",
+                source_range: [302; 302),
+                delete: [302; 302),
+                insert: "PUBLIC_CONST",
+                kind: Const,
+                detail: "pub(super) const PUBLIC_CONST: u32 = 1;",
+            },
+            CompletionItem {
+                label: "PublicType",
+                source_range: [302; 302),
+                delete: [302; 302),
+                insert: "PublicType",
+                kind: TypeAlias,
+                detail: "pub(super) type PublicType = u32;",
+            },
+            CompletionItem {
+                label: "public_method()",
+                source_range: [302; 302),
+                delete: [302; 302),
+                insert: "public_method()$0",
+                kind: Function,
+                lookup: "public_method",
+                detail: "pub(super) fn public_method()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn completes_enum_associated_method() {
        assert_debug_snapshot!(
            do_reference_completion(
@@ -835,4 +934,37 @@ mod tests {
        "###
        );
    }
+    #[test]
+    fn completes_in_simple_macro_call() {
+        let completions = do_reference_completion(
+            r#"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn main() { m!(self::f<|>); }
+                fn foo() {}
+            "#,
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "foo()",
+                source_range: [93; 94),
+                delete: [93; 94),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [93; 94),
+                delete: [93; 94),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###);
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_pattern.rs b/crates/ra_ide/src/completion/complete_pattern.rs
index c2c6ca002..fa8aeceda 100644
--- a/crates/ra_ide/src/completion/complete_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_pattern.rs
@@ -86,4 +86,22 @@ mod tests {
        ]
        "###);
    }
+    #[test]
+    fn completes_in_simple_macro_call() {
+        // FIXME: doesn't work yet because of missing error recovery in macro expansion
+        let completions = complete(
+            r"
+            macro_rules! m { ($e:expr) => { $e } }
+            enum E { X }
+            fn foo() {
+               m!(match E::X {
+                   <|>
+               })
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"[]"###);
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 8a74f993a..65ecea125 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -67,8 +67,8 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
 fn postfix_snippet(ctx: &CompletionContext, label: &str, detail: &str, snippet: &str) -> Builder {
    let edit = {
-        let receiver_range =
+        let receiver_syntax = ctx.dot_receiver.as_ref().expect("no receiver available").syntax();
-            ctx.dot_receiver.as_ref().expect("no receiver available").syntax().text_range();
+        let receiver_range = ctx.sema.original_range(receiver_syntax).range;
        let delete_range = TextRange::from_to(receiver_range.start(), ctx.source_range().end());
        TextEdit::replace(delete_range, snippet.to_string())
    };
@@ -279,4 +279,65 @@ mod tests {
        "###
        );
    }
+    #[test]
+    fn works_in_simple_macro() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn main() {
+                    let bar: u8 = 12;
+                    m!(bar.b<|>)
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "Box::new(bar)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "dbg!(bar)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "match bar {\n    ${1:_} => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "!bar",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "&bar",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "&mut bar",
+                detail: "&mut expr",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_record_literal.rs b/crates/ra_ide/src/completion/complete_record_literal.rs
index f98353d76..be6e4194f 100644
--- a/crates/ra_ide/src/completion/complete_record_literal.rs
+++ b/crates/ra_ide/src/completion/complete_record_literal.rs
@@ -153,4 +153,29 @@ mod tests {
        ]
        "###);
    }
+    #[test]
+    fn test_record_literal_field_in_simple_macro() {
+        let completions = complete(
+            r"
+            macro_rules! m { ($e:expr) => { $e } }
+            struct A { the_field: u32 }
+            fn foo() {
+               m!(A { the<|> })
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [137; 140),
+                delete: [137; 140),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_record_pattern.rs b/crates/ra_ide/src/completion/complete_record_pattern.rs
index 9bdeae49f..687c57d3e 100644
--- a/crates/ra_ide/src/completion/complete_record_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_record_pattern.rs
@@ -87,4 +87,32 @@ mod tests {
        ]
        "###);
    }
+    #[test]
+    fn test_record_pattern_field_in_simple_macro() {
+        let completions = complete(
+            r"
+            macro_rules! m { ($e:expr) => { $e } }
+            struct S { foo: u32 }
+            fn process(f: S) {
+                m!(match f {
+                    S { f<|>: 92 } => (),
+                })
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "foo",
+                source_range: [171; 172),
+                delete: [171; 172),
+                insert: "foo",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_scope.rs b/crates/ra_ide/src/completion/complete_scope.rs
index 2b9a0e556..eb3c8cf1b 100644
--- a/crates/ra_ide/src/completion/complete_scope.rs
+++ b/crates/ra_ide/src/completion/complete_scope.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! Completion of names from the current scope, e.g. locals and imported items.
 use crate::completion::{CompletionContext, Completions};
@@ -797,4 +797,72 @@ mod tests {
        "###
        )
    }
+    #[test]
+    fn completes_in_simple_macro_1() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn quux(x: i32) {
+                    let y = 92;
+                    m!(<|>);
+                }
+                "
+            ),
+            @"[]"
+        );
+    }
+    #[test]
+    fn completes_in_simple_macro_2() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn quux(x: i32) {
+                    let y = 92;
+                    m!(x<|>);
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "m!",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "m!($0)",
+                kind: Macro,
+                detail: "macro_rules! m",
+            },
+            CompletionItem {
+                label: "quux(…)",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "quux(${1:x})$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux(x: i32)",
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "x",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "y",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "y",
+                kind: Binding,
+                detail: "i32",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 9aa5a705d..40535c09e 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -5,7 +5,7 @@ use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::{find_covering_element, find_node_at_offset},
-    ast, AstNode, SourceFile,
+    ast, AstNode,
    SyntaxKind::*,
    SyntaxNode, SyntaxToken, TextRange, TextUnit,
 };
@@ -20,8 +20,11 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) sema: Semantics<'a, RootDatabase>,
    pub(super) db: &'a RootDatabase,
    pub(super) offset: TextUnit,
+    /// The token before the cursor, in the original file.
+    pub(super) original_token: SyntaxToken,
+    /// The token before the cursor, in the macro-expanded file.
    pub(super) token: SyntaxToken,
-    pub(super) module: Option<hir::Module>,
+    pub(super) krate: Option<hir::Crate>,
    pub(super) name_ref_syntax: Option<ast::NameRef>,
    pub(super) function_syntax: Option<ast::FnDef>,
    pub(super) use_item_syntax: Option<ast::UseItem>,
@@ -67,15 +70,20 @@ impl<'a> CompletionContext<'a> {
            let edit = AtomTextEdit::insert(position.offset, "intellijRulezz".to_string());
            parse.reparse(&edit).tree()
        };
+        let fake_ident_token =
+            file_with_fake_ident.syntax().token_at_offset(position.offset).right_biased().unwrap();
-        let module = sema.to_module_def(position.file_id);
+        let krate = sema.to_module_def(position.file_id).map(|m| m.krate());
-        let token = original_file.syntax().token_at_offset(position.offset).left_biased()?;
+        let original_token =
+            original_file.syntax().token_at_offset(position.offset).left_biased()?;
+        let token = sema.descend_into_macros(original_token.clone());
        let mut ctx = CompletionContext {
            sema,
            db,
+            original_token,
            token,
            offset: position.offset,
-            module,
+            krate,
            name_ref_syntax: None,
            function_syntax: None,
            use_item_syntax: None,
@@ -95,15 +103,57 @@ impl<'a> CompletionContext<'a> {
            has_type_args: false,
            dot_receiver_is_ambiguous_float_literal: false,
        };
-        ctx.fill(&original_file, file_with_fake_ident, position.offset);
+        let mut original_file = original_file.syntax().clone();
+        let mut hypothetical_file = file_with_fake_ident.syntax().clone();
+        let mut offset = position.offset;
+        let mut fake_ident_token = fake_ident_token;
+        // Are we inside a macro call?
+        while let (Some(actual_macro_call), Some(macro_call_with_fake_ident)) = (
+            find_node_at_offset::<ast::MacroCall>(&original_file, offset),
+            find_node_at_offset::<ast::MacroCall>(&hypothetical_file, offset),
+        ) {
+            if actual_macro_call.path().as_ref().map(|s| s.syntax().text())
+                != macro_call_with_fake_ident.path().as_ref().map(|s| s.syntax().text())
+            {
+                break;
+            }
+            let hypothetical_args = match macro_call_with_fake_ident.token_tree() {
+                Some(tt) => tt,
+                None => break,
+            };
+            if let (Some(actual_expansion), Some(hypothetical_expansion)) = (
+                ctx.sema.expand(&actual_macro_call),
+                ctx.sema.expand_hypothetical(
+                    &actual_macro_call,
+                    &hypothetical_args,
+                    fake_ident_token,
+                ),
+            ) {
+                let new_offset = hypothetical_expansion.1.text_range().start();
+                if new_offset >= actual_expansion.text_range().end() {
+                    break;
+                }
+                original_file = actual_expansion;
+                hypothetical_file = hypothetical_expansion.0;
+                fake_ident_token = hypothetical_expansion.1;
+                offset = new_offset;
+            } else {
+                break;
+            }
+        }
+        ctx.fill(&original_file, hypothetical_file, offset);
        Some(ctx)
    }
    // The range of the identifier that is being completed.
    pub(crate) fn source_range(&self) -> TextRange {
+        // check kind of macro-expanded token, but use range of original token
        match self.token.kind() {
            // workaroud when completion is triggered by trigger characters.
-            IDENT => self.token.text_range(),
+            IDENT => self.original_token.text_range(),
            _ => TextRange::offset_len(self.offset, 0.into()),
        }
    }
@@ -114,27 +164,24 @@ impl<'a> CompletionContext<'a> {
    fn fill(
        &mut self,
-        original_file: &ast::SourceFile,
+        original_file: &SyntaxNode,
-        file_with_fake_ident: ast::SourceFile,
+        file_with_fake_ident: SyntaxNode,
        offset: TextUnit,
    ) {
        // First, let's try to complete a reference to some declaration.
-        if let Some(name_ref) =
+        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&file_with_fake_ident, offset) {
-            find_node_at_offset::<ast::NameRef>(file_with_fake_ident.syntax(), offset)
-        {
            // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`.
            // See RFC#1685.
            if is_node::<ast::Param>(name_ref.syntax()) {
                self.is_param = true;
                return;
            }
-            self.classify_name_ref(original_file, name_ref);
+            self.classify_name_ref(original_file, name_ref, offset);
        }
        // Otherwise, see if this is a declaration. We can use heuristics to
        // suggest declaration names, see `CompletionKind::Magic`.
-        if let Some(name) = find_node_at_offset::<ast::Name>(file_with_fake_ident.syntax(), offset)
+        if let Some(name) = find_node_at_offset::<ast::Name>(&file_with_fake_ident, offset) {
-        {
            if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::BindPat::cast) {
                let parent = bind_pat.syntax().parent();
                if parent.clone().and_then(ast::MatchArm::cast).is_some()
@@ -148,23 +195,29 @@ impl<'a> CompletionContext<'a> {
                return;
            }
            if name.syntax().ancestors().find_map(ast::RecordFieldPatList::cast).is_some() {
-                self.record_lit_pat = find_node_at_offset(original_file.syntax(), self.offset);
+                self.record_lit_pat =
+                    self.sema.find_node_at_offset_with_macros(&original_file, offset);
            }
        }
    }
-    fn classify_name_ref(&mut self, original_file: &SourceFile, name_ref: ast::NameRef) {
+    fn classify_name_ref(
+        &mut self,
+        original_file: &SyntaxNode,
+        name_ref: ast::NameRef,
+        offset: TextUnit,
+    ) {
        self.name_ref_syntax =
-            find_node_at_offset(original_file.syntax(), name_ref.syntax().text_range().start());
+            find_node_at_offset(&original_file, name_ref.syntax().text_range().start());
        let name_range = name_ref.syntax().text_range();
        if name_ref.syntax().parent().and_then(ast::RecordField::cast).is_some() {
-            self.record_lit_syntax = find_node_at_offset(original_file.syntax(), self.offset);
+            self.record_lit_syntax =
+                self.sema.find_node_at_offset_with_macros(&original_file, offset);
        }
        self.impl_def = self
-            .token
+            .sema
-            .parent()
+            .ancestors_with_macros(self.token.parent())
-            .ancestors()
            .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
            .find_map(ast::ImplDef::cast);
@@ -183,12 +236,12 @@ impl<'a> CompletionContext<'a> {
            _ => (),
        }
-        self.use_item_syntax = self.token.parent().ancestors().find_map(ast::UseItem::cast);
+        self.use_item_syntax =
+            self.sema.ancestors_with_macros(self.token.parent()).find_map(ast::UseItem::cast);
        self.function_syntax = self
-            .token
+            .sema
-            .parent()
+            .ancestors_with_macros(self.token.parent())
-            .ancestors()
            .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
            .find_map(ast::FnDef::cast);
@@ -242,7 +295,7 @@ impl<'a> CompletionContext<'a> {
                if let Some(off) = name_ref.syntax().text_range().start().checked_sub(2.into()) {
                    if let Some(if_expr) =
-                        find_node_at_offset::<ast::IfExpr>(original_file.syntax(), off)
+                        self.sema.find_node_at_offset_with_macros::<ast::IfExpr>(original_file, off)
                    {
                        if if_expr.syntax().text_range().end()
                            < name_ref.syntax().text_range().start()
@@ -259,7 +312,7 @@ impl<'a> CompletionContext<'a> {
            self.dot_receiver = field_expr
                .expr()
                .map(|e| e.syntax().text_range())
-                .and_then(|r| find_node_with_range(original_file.syntax(), r));
+                .and_then(|r| find_node_with_range(original_file, r));
            self.dot_receiver_is_ambiguous_float_literal =
                if let Some(ast::Expr::Literal(l)) = &self.dot_receiver {
                    match l.kind() {
@@ -275,7 +328,7 @@ impl<'a> CompletionContext<'a> {
            self.dot_receiver = method_call_expr
                .expr()
                .map(|e| e.syntax().text_range())
-                .and_then(|r| find_node_with_range(original_file.syntax(), r));
+                .and_then(|r| find_node_with_range(original_file, r));
            self.is_call = true;
        }
    }
diff --git a/crates/ra_ide/src/display.rs b/crates/ra_ide/src/display.rs
index 1c26a8697..eaeaaa2b4 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -68,17 +68,23 @@ pub(crate) fn macro_label(node: &ast::MacroCall) -> String {
 }
 pub(crate) fn rust_code_markup<CODE: AsRef<str>>(val: CODE) -> String {
-    rust_code_markup_with_doc::<_, &str>(val, None)
+    rust_code_markup_with_doc::<_, &str>(val, None, None)
 }
-pub(crate) fn rust_code_markup_with_doc<CODE, DOC>(val: CODE, doc: Option<DOC>) -> String
+pub(crate) fn rust_code_markup_with_doc<CODE, DOC>(
+    val: CODE,
+    doc: Option<DOC>,
+    mod_path: Option<String>,
+) -> String
 where
    CODE: AsRef<str>,
    DOC: AsRef<str>,
 {
+    let mod_path =
+        mod_path.filter(|path| !path.is_empty()).map(|path| path + "\n").unwrap_or_default();
    if let Some(doc) = doc {
-        format!("```rust\n{}\n```\n\n{}", val.as_ref(), doc.as_ref())
+        format!("```rust\n{}{}\n```\n\n{}", mod_path, val.as_ref(), doc.as_ref())
    } else {
-        format!("```rust\n{}\n```", val.as_ref())
+        format!("```rust\n{}{}\n```", mod_path, val.as_ref())
    }
 }
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index e9c682557..25e038a55 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -1,6 +1,10 @@
 //! FIXME: write short doc here
-use hir::{Adt, HasSource, HirDisplay, Semantics};
+use hir::{
+    Adt, AsAssocItem, AssocItemContainer, FieldSource, HasSource, HirDisplay, ModuleDef,
+    ModuleSource, Semantics,
+};
+use ra_db::SourceDatabase;
 use ra_ide_db::{
    defs::{classify_name, classify_name_ref, Definition},
    RootDatabase,
@@ -16,6 +20,8 @@ use crate::{
    display::{macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel},
    FilePosition, RangeInfo,
 };
+use itertools::Itertools;
+use std::iter::once;
 /// Contains the results when hovering over an item
 #[derive(Debug, Clone)]
@@ -83,44 +89,86 @@ impl HoverResult {
    }
 }
-fn hover_text(docs: Option<String>, desc: Option<String>) -> Option<String> {
+fn hover_text(
-    match (desc, docs) {
+    docs: Option<String>,
-        (Some(desc), docs) => Some(rust_code_markup_with_doc(desc, docs)),
+    desc: Option<String>,
-        (None, Some(docs)) => Some(docs),
+    mod_path: Option<String>,
+) -> Option<String> {
+    match (desc, docs, mod_path) {
+        (Some(desc), docs, mod_path) => Some(rust_code_markup_with_doc(desc, docs, mod_path)),
+        (None, Some(docs), _) => Some(docs),
+        _ => None,
+    }
+}
+fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String> {
+    match def {
+        Definition::StructField(f) => Some(f.parent_def(db).name(db)),
+        Definition::Local(l) => l.parent(db).name(db),
+        Definition::ModuleDef(md) => match md {
+            ModuleDef::Function(f) => match f.as_assoc_item(db)?.container(db) {
+                AssocItemContainer::Trait(t) => Some(t.name(db)),
+                AssocItemContainer::ImplDef(i) => i.target_ty(db).as_adt().map(|adt| adt.name(db)),
+            },
+            ModuleDef::EnumVariant(e) => Some(e.parent_enum(db).name(db)),
+            _ => None,
+        },
+        Definition::SelfType(i) => i.target_ty(db).as_adt().map(|adt| adt.name(db)),
        _ => None,
    }
+    .map(|name| name.to_string())
+}
+fn determine_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> {
+    let mod_path = def.module(db).map(|module| {
+        once(db.crate_graph()[module.krate().into()].display_name.clone())
+            .chain(
+                module
+                    .path_to_root(db)
+                    .into_iter()
+                    .rev()
+                    .map(|it| it.name(db).map(|name| name.to_string())),
+            )
+            .chain(once(definition_owner_name(db, def)))
+            .flatten()
+            .join("::")
+    });
+    mod_path
 }
 fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<String> {
+    let mod_path = determine_mod_path(db, &def);
    return match def {
        Definition::Macro(it) => {
            let src = it.source(db);
-            hover_text(src.value.doc_comment_text(), Some(macro_label(&src.value)))
+            hover_text(src.value.doc_comment_text(), Some(macro_label(&src.value)), mod_path)
        }
        Definition::StructField(it) => {
            let src = it.source(db);
            match src.value {
-                hir::FieldSource::Named(it) => hover_text(it.doc_comment_text(), it.short_label()),
+                FieldSource::Named(it) => {
+                    hover_text(it.doc_comment_text(), it.short_label(), mod_path)
+                }
                _ => None,
            }
        }
        Definition::ModuleDef(it) => match it {
-            hir::ModuleDef::Module(it) => match it.definition_source(db).value {
+            ModuleDef::Module(it) => match it.definition_source(db).value {
-                hir::ModuleSource::Module(it) => {
+                ModuleSource::Module(it) => {
-                    hover_text(it.doc_comment_text(), it.short_label())
+                    hover_text(it.doc_comment_text(), it.short_label(), mod_path)
                }
                _ => None,
            },
-            hir::ModuleDef::Function(it) => from_def_source(db, it),
+            ModuleDef::Function(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Adt(Adt::Struct(it)) => from_def_source(db, it),
+            ModuleDef::Adt(Adt::Struct(it)) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Adt(Adt::Union(it)) => from_def_source(db, it),
+            ModuleDef::Adt(Adt::Union(it)) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Adt(Adt::Enum(it)) => from_def_source(db, it),
+            ModuleDef::Adt(Adt::Enum(it)) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::EnumVariant(it) => from_def_source(db, it),
+            ModuleDef::EnumVariant(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Const(it) => from_def_source(db, it),
+            ModuleDef::Const(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Static(it) => from_def_source(db, it),
+            ModuleDef::Static(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Trait(it) => from_def_source(db, it),
+            ModuleDef::Trait(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::TypeAlias(it) => from_def_source(db, it),
+            ModuleDef::TypeAlias(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::BuiltinType(it) => Some(it.to_string()),
+            ModuleDef::BuiltinType(it) => Some(it.to_string()),
        },
        Definition::Local(it) => {
            Some(rust_code_markup(it.ty(db).display_truncated(db, None).to_string()))
@@ -131,13 +179,13 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<Strin
        }
    };
-    fn from_def_source<A, D>(db: &RootDatabase, def: D) -> Option<String>
+    fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<String>
    where
        D: HasSource<Ast = A>,
        A: ast::DocCommentsOwner + ast::NameOwner + ShortLabel,
    {
        let src = def.source(db);
-        hover_text(src.value.doc_comment_text(), src.value.short_label())
+        hover_text(src.value.doc_comment_text(), src.value.short_label(), mod_path)
    }
 }
@@ -345,7 +393,7 @@ mod tests {
                };
            }
        "#,
-            &["field_a: u32"],
+            &["Foo\nfield_a: u32"],
        );
        // Hovering over the field in the definition
@@ -362,7 +410,7 @@ mod tests {
                };
            }
        "#,
-            &["field_a: u32"],
+            &["Foo\nfield_a: u32"],
        );
    }
@@ -415,7 +463,7 @@ fn main() {
            ",
        );
        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("Some"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("Option\nSome"));
        let (analysis, position) = single_file_with_position(
            "
@@ -442,6 +490,7 @@ fn main() {
            }
        "#,
            &["
+Option
 None
 ```
@@ -462,6 +511,7 @@ The None variant
            }
        "#,
            &["
+Option
 Some
 ```
@@ -528,21 +578,23 @@ fn func(foo: i32) { if true { <|>foo; }; }
    fn test_hover_infer_associated_method_exact() {
        let (analysis, position) = single_file_with_position(
            "
-            struct Thing { x: u32 }
+            mod wrapper {
+                struct Thing { x: u32 }
-            impl Thing {
+                impl Thing {
-                fn new() -> Thing {
+                    fn new() -> Thing {
-                    Thing { x: 0 }
+                        Thing { x: 0 }
+                    }
                }
            }
            fn main() {
-                let foo_test = Thing::new<|>();
+                let foo_test = wrapper::Thing::new<|>();
            }
            ",
        );
        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("fn new() -> Thing"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("wrapper::Thing\nfn new() -> Thing"));
        assert_eq!(hover.info.is_exact(), true);
    }
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 69098a630..cf0cbdbd0 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -119,6 +119,12 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
        return true;
    }
+    if let Some(Adt::Struct(s)) = pat_ty.as_adt() {
+        if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.syntax().to_string() {
+            return true;
+        }
+    }
    for node in bind_pat.syntax().ancestors() {
        match_ast! {
            match node {
@@ -943,4 +949,30 @@ fn main() {
        "###
        );
    }
+    #[test]
+    fn unit_structs_have_no_type_hints() {
+        let (analysis, file_id) = single_file(
+            r#"
+enum CustomResult<T, E> {
+    Ok(T),
+    Err(E),
+}
+use CustomResult::*;
+struct SyntheticSyntax;
+fn main() {
+    match Ok(()) {
+        Ok(_) => (),
+        Err(SyntheticSyntax) => (),
+    }
+}"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, Some(8)).unwrap(), @r###"
+        []
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 4dfe0553e..c60e86aea 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -211,7 +211,13 @@ impl Analysis {
        // Default to enable test for single file.
        let mut cfg_options = CfgOptions::default();
        cfg_options.insert_atom("test".into());
-        crate_graph.add_crate_root(file_id, Edition::Edition2018, cfg_options, Env::default());
+        crate_graph.add_crate_root(
+            file_id,
+            Edition::Edition2018,
+            None,
+            cfg_options,
+            Env::default(),
+        );
        change.add_file(source_root, file_id, "main.rs".into(), Arc::new(text));
        change.set_crate_graph(crate_graph);
        host.apply_change(change);
@@ -415,12 +421,12 @@ impl Analysis {
    /// Returns the edition of the given crate.
    pub fn crate_edition(&self, crate_id: CrateId) -> Cancelable<Edition> {
-        self.with_db(|db| db.crate_graph().edition(crate_id))
+        self.with_db(|db| db.crate_graph()[crate_id].edition)
    }
    /// Returns the root file of the given crate.
    pub fn crate_root(&self, crate_id: CrateId) -> Cancelable<FileId> {
-        self.with_db(|db| db.crate_graph().crate_root(crate_id))
+        self.with_db(|db| db.crate_graph()[crate_id].root_file_id)
    }
    /// Returns the set of possible targets to run for the current file.
diff --git a/crates/ra_ide/src/mock_analysis.rs b/crates/ra_ide/src/mock_analysis.rs
index f4cd6deb7..90f84b052 100644
--- a/crates/ra_ide/src/mock_analysis.rs
+++ b/crates/ra_ide/src/mock_analysis.rs
@@ -99,13 +99,19 @@ impl MockAnalysis {
                root_crate = Some(crate_graph.add_crate_root(
                    file_id,
                    Edition2018,
+                    None,
                    cfg_options,
                    Env::default(),
                ));
            } else if path.ends_with("/lib.rs") {
-                let other_crate =
-                    crate_graph.add_crate_root(file_id, Edition2018, cfg_options, Env::default());
                let crate_name = path.parent().unwrap().file_name().unwrap();
+                let other_crate = crate_graph.add_crate_root(
+                    file_id,
+                    Edition2018,
+                    Some(crate_name.to_owned()),
+                    cfg_options,
+                    Env::default(),
+                );
                if let Some(root_crate) = root_crate {
                    crate_graph
                        .add_dep(root_crate, CrateName::new(crate_name).unwrap(), other_crate)
diff --git a/crates/ra_ide/src/parent_module.rs b/crates/ra_ide/src/parent_module.rs
index 2c4bdb039..b73cefd97 100644
--- a/crates/ra_ide/src/parent_module.rs
+++ b/crates/ra_ide/src/parent_module.rs
@@ -133,6 +133,7 @@ mod tests {
        let crate_id = crate_graph.add_crate_root(
            root_file,
            Edition2018,
+            None,
            CfgOptions::default(),
            Env::default(),
        );
diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
index 52f0f23df..de4f5bce0 100644
--- a/crates/ra_ide_db/Cargo.toml
+++ b/crates/ra_ide_db/Cargo.toml
@@ -13,7 +13,7 @@ wasm = []
 [dependencies]
 log = "0.4.8"
 rayon = "1.3.0"
-fst = { version = "0.3.5", default-features = false }
+fst = { version = "0.4", default-features = false }
 rustc-hash = "1.1.0"
 superslice = "1.0.0"
 once_cell = "1.3.1"
diff --git a/crates/ra_ide_db/src/change.rs b/crates/ra_ide_db/src/change.rs
index 8b5be9d21..628cf6416 100644
--- a/crates/ra_ide_db/src/change.rs
+++ b/crates/ra_ide_db/src/change.rs
@@ -5,7 +5,7 @@ use std::{fmt, sync::Arc, time};
 use ra_db::{
    salsa::{Database, Durability, SweepStrategy},
-    CrateGraph, CrateId, FileId, RelativePathBuf, SourceDatabase, SourceDatabaseExt, SourceRoot,
+    CrateGraph, FileId, RelativePathBuf, SourceDatabase, SourceDatabaseExt, SourceRoot,
    SourceRootId,
 };
 use ra_prof::{memory_usage, profile, Bytes};
@@ -88,10 +88,6 @@ impl AnalysisChange {
        self.crate_graph = Some(graph);
    }
-    pub fn set_debug_crate_name(&mut self, crate_id: CrateId, name: String) {
-        self.debug_data.crate_names.insert(crate_id, name);
-    }
    pub fn set_debug_root_path(&mut self, source_root_id: SourceRootId, path: String) {
        self.debug_data.root_paths.insert(source_root_id, path);
    }
diff --git a/crates/ra_ide_db/src/lib.rs b/crates/ra_ide_db/src/lib.rs
index 79f48c9e3..a105c7556 100644
--- a/crates/ra_ide_db/src/lib.rs
+++ b/crates/ra_ide_db/src/lib.rs
@@ -131,12 +131,10 @@ fn line_index(db: &impl LineIndexDatabase, file_id: FileId) -> Arc<LineIndex> {
 #[derive(Debug, Default, Clone)]
 pub(crate) struct DebugData {
    pub(crate) root_paths: FxHashMap<SourceRootId, String>,
-    pub(crate) crate_names: FxHashMap<CrateId, String>,
 }
 impl DebugData {
    pub(crate) fn merge(&mut self, other: DebugData) {
        self.root_paths.extend(other.root_paths.into_iter());
-        self.crate_names.extend(other.crate_names.into_iter());
    }
 }
diff --git a/crates/ra_ide_db/src/symbol_index.rs b/crates/ra_ide_db/src/symbol_index.rs
index e6b3126b6..884359ee3 100644
--- a/crates/ra_ide_db/src/symbol_index.rs
+++ b/crates/ra_ide_db/src/symbol_index.rs
@@ -163,7 +163,7 @@ pub fn index_resolve(db: &RootDatabase, name_ref: &ast::NameRef) -> Vec<FileSymb
 #[derive(Default)]
 pub struct SymbolIndex {
    symbols: Vec<FileSymbol>,
-    map: fst::Map,
+    map: fst::Map<Vec<u8>>,
 }
 impl fmt::Debug for SymbolIndex {
@@ -221,7 +221,7 @@ impl SymbolIndex {
            builder.insert(key, value).unwrap();
        }
-        let map = fst::Map::from_bytes(builder.into_inner().unwrap()).unwrap();
+        let map = fst::Map::new(builder.into_inner().unwrap()).unwrap();
        SymbolIndex { symbols, map }
    }
diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs
index 2c6ae5658..43afe24cc 100644
--- a/crates/ra_mbe/src/lib.rs
+++ b/crates/ra_mbe/src/lib.rs
@@ -31,7 +31,8 @@ pub enum ExpandError {
 }
 pub use crate::syntax_bridge::{
-    ast_to_token_tree, syntax_node_to_token_tree, token_tree_to_syntax_node, TokenMap,
+    ast_to_token_tree, parse_to_token_tree, syntax_node_to_token_tree, token_tree_to_syntax_node,
+    TokenMap,
 };
 /// This struct contains AST for a single `macro_rules` definition. What might
diff --git a/crates/ra_mbe/src/mbe_expander/matcher.rs b/crates/ra_mbe/src/mbe_expander/matcher.rs
index ffba03898..49c53183a 100644
--- a/crates/ra_mbe/src/mbe_expander/matcher.rs
+++ b/crates/ra_mbe/src/mbe_expander/matcher.rs
@@ -247,6 +247,7 @@ impl<'a> TtIter<'a> {
        ra_parser::parse_fragment(&mut src, &mut sink, fragment_kind);
        if !sink.cursor.is_root() || sink.error {
+            // FIXME better recovery in this case would help completion inside macros immensely
            return Err(());
        }
@@ -375,7 +376,8 @@ fn match_meta_var(kind: &str, input: &mut TtIter) -> Result<Option<Fragment>, Ex
            return Ok(Some(Fragment::Tokens(tt)));
        }
    };
-    let tt = input.expect_fragment(fragment).map_err(|()| err!())?;
+    let tt =
+        input.expect_fragment(fragment).map_err(|()| err!("fragment did not parse as {}", kind))?;
    let fragment = if kind == "expr" { Fragment::Ast(tt) } else { Fragment::Tokens(tt) };
    Ok(Some(fragment))
 }
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index fb9fa5314..fcb73fbc7 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -2,8 +2,10 @@
 use ra_parser::{FragmentKind, ParseError, TreeSink};
 use ra_syntax::{
-    ast, AstToken, NodeOrToken, Parse, SmolStr, SyntaxKind, SyntaxKind::*, SyntaxNode,
+    ast::{self, make::tokens::doc_comment},
-    SyntaxTreeBuilder, TextRange, TextUnit, T,
+    tokenize, AstToken, NodeOrToken, Parse, SmolStr, SyntaxKind,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxTreeBuilder, TextRange, TextUnit, Token, T,
 };
 use rustc_hash::FxHashMap;
 use std::iter::successors;
@@ -48,9 +50,11 @@ pub fn ast_to_token_tree(ast: &impl ast::AstNode) -> Option<(tt::Subtree, TokenM
 /// will consume).
 pub fn syntax_node_to_token_tree(node: &SyntaxNode) -> Option<(tt::Subtree, TokenMap)> {
    let global_offset = node.text_range().start();
-    let mut c = Convertor { map: TokenMap::default(), global_offset, next_id: 0 };
+    let mut c = Convertor {
+        id_alloc: { TokenIdAlloc { map: TokenMap::default(), global_offset, next_id: 0 } },
+    };
    let subtree = c.go(node)?;
-    Some((subtree, c.map))
+    Some((subtree, c.id_alloc.map))
 }
 // The following items are what `rustc` macro can be parsed into :
@@ -89,6 +93,28 @@ pub fn token_tree_to_syntax_node(
    Ok((parse, range_map))
 }
+/// Convert a string to a `TokenTree`
+pub fn parse_to_token_tree(text: &str) -> Option<(tt::Subtree, TokenMap)> {
+    let (tokens, errors) = tokenize(text);
+    if !errors.is_empty() {
+        return None;
+    }
+    let mut conv = RawConvertor {
+        text,
+        offset: TextUnit::default(),
+        inner: tokens.iter(),
+        id_alloc: TokenIdAlloc {
+            map: Default::default(),
+            global_offset: TextUnit::default(),
+            next_id: 0,
+        },
+    };
+    let subtree = conv.go()?;
+    Some((subtree, conv.id_alloc.map))
+}
 impl TokenMap {
    pub fn token_by_range(&self, relative_range: TextRange) -> Option<tt::TokenId> {
        let &(token_id, _) = self.entries.iter().find(|(_, range)| match range {
@@ -118,6 +144,14 @@ impl TokenMap {
        self.entries
            .push((token_id, TokenTextRange::Delimiter(open_relative_range, close_relative_range)));
    }
+    fn update_close_delim(&mut self, token_id: tt::TokenId, close_relative_range: TextRange) {
+        if let Some(entry) = self.entries.iter_mut().find(|(tid, _)| *tid == token_id) {
+            if let TokenTextRange::Delimiter(dim, _) = entry.1 {
+                entry.1 = TokenTextRange::Delimiter(dim, close_relative_range);
+            }
+        }
+    }
 }
 /// Returns the textual content of a doc comment block as a quoted string
@@ -188,12 +222,161 @@ fn convert_doc_comment(token: &ra_syntax::SyntaxToken) -> Option<Vec<tt::TokenTr
    }
 }
-struct Convertor {
+struct TokenIdAlloc {
    map: TokenMap,
    global_offset: TextUnit,
    next_id: u32,
 }
+impl TokenIdAlloc {
+    fn alloc(&mut self, absolute_range: TextRange) -> tt::TokenId {
+        let relative_range = absolute_range - self.global_offset;
+        let token_id = tt::TokenId(self.next_id);
+        self.next_id += 1;
+        self.map.insert(token_id, relative_range);
+        token_id
+    }
+    fn delim(&mut self, open_abs_range: TextRange, close_abs_range: TextRange) -> tt::TokenId {
+        let open_relative_range = open_abs_range - self.global_offset;
+        let close_relative_range = close_abs_range - self.global_offset;
+        let token_id = tt::TokenId(self.next_id);
+        self.next_id += 1;
+        self.map.insert_delim(token_id, open_relative_range, close_relative_range);
+        token_id
+    }
+    fn open_delim(&mut self, open_abs_range: TextRange) -> tt::TokenId {
+        let token_id = tt::TokenId(self.next_id);
+        self.next_id += 1;
+        self.map.insert_delim(token_id, open_abs_range, open_abs_range);
+        token_id
+    }
+    fn close_delim(&mut self, id: tt::TokenId, close_abs_range: TextRange) {
+        self.map.update_close_delim(id, close_abs_range);
+    }
+}
+/// A Raw Token (straightly from lexer) convertor
+struct RawConvertor<'a> {
+    text: &'a str,
+    offset: TextUnit,
+    id_alloc: TokenIdAlloc,
+    inner: std::slice::Iter<'a, Token>,
+}
+impl RawConvertor<'_> {
+    fn go(&mut self) -> Option<tt::Subtree> {
+        let mut subtree = tt::Subtree::default();
+        subtree.delimiter = None;
+        while self.peek().is_some() {
+            self.collect_leaf(&mut subtree.token_trees);
+        }
+        if subtree.token_trees.is_empty() {
+            return None;
+        }
+        if subtree.token_trees.len() == 1 {
+            if let tt::TokenTree::Subtree(first) = &subtree.token_trees[0] {
+                return Some(first.clone());
+            }
+        }
+        Some(subtree)
+    }
+    fn bump(&mut self) -> Option<(Token, TextRange)> {
+        let token = self.inner.next()?;
+        let range = TextRange::offset_len(self.offset, token.len);
+        self.offset += token.len;
+        Some((*token, range))
+    }
+    fn peek(&self) -> Option<Token> {
+        self.inner.as_slice().get(0).cloned()
+    }
+    fn collect_leaf(&mut self, result: &mut Vec<tt::TokenTree>) {
+        let (token, range) = match self.bump() {
+            None => return,
+            Some(it) => it,
+        };
+        let k: SyntaxKind = token.kind;
+        if k == COMMENT {
+            let node = doc_comment(&self.text[range]);
+            if let Some(tokens) = convert_doc_comment(&node) {
+                result.extend(tokens);
+            }
+            return;
+        }
+        result.push(if k.is_punct() {
+            let delim = match k {
+                T!['('] => Some((tt::DelimiterKind::Parenthesis, T![')'])),
+                T!['{'] => Some((tt::DelimiterKind::Brace, T!['}'])),
+                T!['['] => Some((tt::DelimiterKind::Bracket, T![']'])),
+                _ => None,
+            };
+            if let Some((kind, closed)) = delim {
+                let mut subtree = tt::Subtree::default();
+                let id = self.id_alloc.open_delim(range);
+                subtree.delimiter = Some(tt::Delimiter { kind, id });
+                while self.peek().map(|it| it.kind != closed).unwrap_or(false) {
+                    self.collect_leaf(&mut subtree.token_trees);
+                }
+                let last_range = match self.bump() {
+                    None => return,
+                    Some(it) => it.1,
+                };
+                self.id_alloc.close_delim(id, last_range);
+                subtree.into()
+            } else {
+                let spacing = match self.peek() {
+                    Some(next)
+                        if next.kind.is_trivia()
+                            || next.kind == T!['[']
+                            || next.kind == T!['{']
+                            || next.kind == T!['('] =>
+                    {
+                        tt::Spacing::Alone
+                    }
+                    Some(next) if next.kind.is_punct() => tt::Spacing::Joint,
+                    _ => tt::Spacing::Alone,
+                };
+                let char =
+                    self.text[range].chars().next().expect("Token from lexer must be single char");
+                tt::Leaf::from(tt::Punct { char, spacing, id: self.id_alloc.alloc(range) }).into()
+            }
+        } else {
+            macro_rules! make_leaf {
+                ($i:ident) => {
+                    tt::$i { id: self.id_alloc.alloc(range), text: self.text[range].into() }.into()
+                };
+            }
+            let leaf: tt::Leaf = match k {
+                T![true] | T![false] => make_leaf!(Literal),
+                IDENT | LIFETIME => make_leaf!(Ident),
+                k if k.is_keyword() => make_leaf!(Ident),
+                k if k.is_literal() => make_leaf!(Literal),
+                _ => return,
+            };
+            leaf.into()
+        });
+    }
+}
+// FIXME: There are some duplicate logic between RawConvertor and Convertor
+// It would be nice to refactor to converting SyntaxNode to ra_parser::Token and thus
+// use RawConvertor directly. But performance-wise it may not be a good idea ?
+struct Convertor {
+    id_alloc: TokenIdAlloc,
+}
 impl Convertor {
    fn go(&mut self, tt: &SyntaxNode) -> Option<tt::Subtree> {
        // This tree is empty
@@ -236,7 +419,7 @@ impl Convertor {
        };
        let delimiter = delimiter_kind.map(|kind| tt::Delimiter {
            kind,
-            id: self.alloc_delim(first_child.text_range(), last_child.text_range()),
+            id: self.id_alloc.delim(first_child.text_range(), last_child.text_range()),
        });
        let mut token_trees = Vec::new();
@@ -273,7 +456,7 @@ impl Convertor {
                                tt::Leaf::from(tt::Punct {
                                    char,
                                    spacing,
-                                    id: self.alloc(token.text_range()),
+                                    id: self.id_alloc.alloc(token.text_range()),
                                })
                                .into(),
                            );
@@ -282,7 +465,7 @@ impl Convertor {
                        macro_rules! make_leaf {
                            ($i:ident) => {
                                tt::$i {
-                                    id: self.alloc(token.text_range()),
+                                    id: self.id_alloc.alloc(token.text_range()),
                                    text: token.text().clone(),
                                }
                                .into()
@@ -313,28 +496,6 @@ impl Convertor {
        let res = tt::Subtree { delimiter, token_trees };
        Some(res)
    }
-    fn alloc(&mut self, absolute_range: TextRange) -> tt::TokenId {
-        let relative_range = absolute_range - self.global_offset;
-        let token_id = tt::TokenId(self.next_id);
-        self.next_id += 1;
-        self.map.insert(token_id, relative_range);
-        token_id
-    }
-    fn alloc_delim(
-        &mut self,
-        open_abs_range: TextRange,
-        close_abs_range: TextRange,
-    ) -> tt::TokenId {
-        let open_relative_range = open_abs_range - self.global_offset;
-        let close_relative_range = close_abs_range - self.global_offset;
-        let token_id = tt::TokenId(self.next_id);
-        self.next_id += 1;
-        self.map.insert_delim(token_id, open_relative_range, close_relative_range);
-        token_id
-    }
 }
 struct TtTreeSink<'a> {
diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs
index 066ce150b..6d5d1e9e6 100644
--- a/crates/ra_mbe/src/tests.rs
+++ b/crates/ra_mbe/src/tests.rs
@@ -1499,12 +1499,20 @@ impl MacroFixture {
    }
 }
-pub(crate) fn parse_macro(macro_definition: &str) -> MacroFixture {
+pub(crate) fn parse_macro(ra_fixture: &str) -> MacroFixture {
-    let source_file = ast::SourceFile::parse(macro_definition).ok().unwrap();
+    let source_file = ast::SourceFile::parse(ra_fixture).ok().unwrap();
    let macro_definition =
        source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
    let (definition_tt, _) = ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
+    let parsed = parse_to_token_tree(
+        &ra_fixture[macro_definition.token_tree().unwrap().syntax().text_range()],
+    )
+    .unwrap()
+    .0;
+    assert_eq!(definition_tt, parsed);
    let rules = MacroRules::parse(&definition_tt).unwrap();
    MacroFixture { rules }
 }
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index bcf12460d..37845ca56 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -14,7 +14,7 @@ use std::{
 use anyhow::{bail, Context, Result};
 use ra_cfg::CfgOptions;
-use ra_db::{CrateGraph, CrateId, CrateName, Edition, Env, FileId};
+use ra_db::{CrateGraph, CrateName, Edition, Env, FileId};
 use rustc_hash::FxHashMap;
 use serde_json::from_reader;
@@ -163,9 +163,8 @@ impl ProjectWorkspace {
        &self,
        default_cfg_options: &CfgOptions,
        load: &mut dyn FnMut(&Path) -> Option<FileId>,
-    ) -> (CrateGraph, FxHashMap<CrateId, String>) {
+    ) -> CrateGraph {
        let mut crate_graph = CrateGraph::default();
-        let mut names = FxHashMap::default();
        match self {
            ProjectWorkspace::Json { project } => {
                let mut crates = FxHashMap::default();
@@ -191,6 +190,8 @@ impl ProjectWorkspace {
                            crate_graph.add_crate_root(
                                file_id,
                                edition,
+                                // FIXME json definitions can store the crate name
+                                None,
                                cfg_options,
                                Env::default(),
                            ),
@@ -233,11 +234,11 @@ impl ProjectWorkspace {
                        let crate_id = crate_graph.add_crate_root(
                            file_id,
                            Edition::Edition2018,
+                            Some(krate.name(&sysroot).to_string()),
                            cfg_options,
                            Env::default(),
                        );
                        sysroot_crates.insert(krate, crate_id);
-                        names.insert(crate_id, krate.name(&sysroot).to_string());
                    }
                }
                for from in sysroot.crates() {
@@ -277,10 +278,10 @@ impl ProjectWorkspace {
                            let crate_id = crate_graph.add_crate_root(
                                file_id,
                                edition,
+                                Some(pkg.name(&cargo).to_string()),
                                cfg_options,
                                Env::default(),
                            );
-                            names.insert(crate_id, pkg.name(&cargo).to_string());
                            if tgt.kind(&cargo) == TargetKind::Lib {
                                lib_tgt = Some(crate_id);
                                pkg_to_lib_crate.insert(pkg, crate_id);
@@ -381,7 +382,7 @@ impl ProjectWorkspace {
                }
            }
        }
-        (crate_graph, names)
+        crate_graph
    }
    pub fn workspace_root_for(&self, path: &Path) -> Option<&Path> {
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 53d6fa562..ae8829807 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -267,6 +267,12 @@ pub mod tokens {
        sf.syntax().first_child_or_token().unwrap().into_token().unwrap()
    }
+    pub fn doc_comment(text: &str) -> SyntaxToken {
+        assert!(!text.trim().is_empty());
+        let sf = SourceFile::parse(text).ok().unwrap();
+        sf.syntax().first_child_or_token().unwrap().into_token().unwrap()
+    }
    pub fn literal(text: &str) -> SyntaxToken {
        assert_eq!(text.trim(), text);
        let lit: ast::Literal = super::ast_from_text(&format!("fn f() {{ let _ = {}; }}", text));
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index b14ebb268..d44f0ef1d 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -20,7 +20,7 @@ globset = "0.4.4"
 itertools = "0.8.2"
 jod-thread = "0.1.0"
 log = "0.4.8"
-lsp-types = { version = "0.72.0", features = ["proposed"] }
+lsp-types = { version = "0.73.0", features = ["proposed"] }
 parking_lot = "0.10.0"
 pico-args = "0.3.1"
 rand = { version = "0.7.3", features = ["small_rng"] }
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 8cd08ecb6..4be987860 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -52,12 +52,11 @@ pub(crate) fn load_cargo(
        opts
    };
-    let (crate_graph, _crate_names) =
+    let crate_graph = ws.to_crate_graph(&default_cfg_options, &mut |path: &Path| {
-        ws.to_crate_graph(&default_cfg_options, &mut |path: &Path| {
+        let vfs_file = vfs.load(path);
-            let vfs_file = vfs.load(path);
+        log::debug!("vfs file {:?} -> {:?}", path, vfs_file);
-            log::debug!("vfs file {:?} -> {:?}", path, vfs_file);
+        vfs_file.map(vfs_file_to_id)
-            vfs_file.map(vfs_file_to_id)
+    });
-        });
    log::debug!("crate graph: {:?}", crate_graph);
    let source_roots = roots
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 580ad1f2c..221f464b6 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -44,6 +44,8 @@ pub struct LspError {
 }
 impl LspError {
+    pub const UNKNOWN_FILE: i32 = -32900;
    pub fn new(code: i32, message: String) -> LspError {
        LspError { code, message }
    }
@@ -631,6 +633,9 @@ fn on_notification(
        }
        Err(not) => not,
    };
+    if not.method.starts_with("$/") {
+        return Ok(());
+    }
    log::error!("unhandled notification: {:?}", not);
    Ok(())
 }
@@ -802,7 +807,14 @@ where
    let response = match result {
        Ok(resp) => Response::new_ok(id, &resp),
        Err(e) => match e.downcast::<LspError>() {
-            Ok(lsp_error) => Response::new_err(id, lsp_error.code, lsp_error.message),
+            Ok(lsp_error) => {
+                if lsp_error.code == LspError::UNKNOWN_FILE {
+                    // Work-around for https://github.com/rust-analyzer/rust-analyzer/issues/1521
+                    Response::new_ok(id, ())
+                } else {
+                    Response::new_err(id, lsp_error.code, lsp_error.message)
+                }
+            }
            Err(e) => {
                if is_canceled(&e) {
                    Response::new_err(
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index b498c90c9..8dc6e8dc0 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -85,11 +85,11 @@ pub fn handle_expand_macro(
 pub fn handle_selection_range(
    world: WorldSnapshot,
    params: req::SelectionRangeParams,
-) -> Result<Vec<req::SelectionRange>> {
+) -> Result<Option<Vec<req::SelectionRange>>> {
    let _p = profile("handle_selection_range");
    let file_id = params.text_document.try_conv_with(&world)?;
    let line_index = world.analysis().file_line_index(file_id)?;
-    params
+    let res: Result<Vec<req::SelectionRange>> = params
        .positions
        .into_iter()
        .map_conv_with(&line_index)
@@ -120,7 +120,9 @@ pub fn handle_selection_range(
            }
            Ok(range)
        })
-        .collect()
+        .collect();
+    Ok(Some(res?))
 }
 pub fn handle_find_matching_brace(
diff --git a/crates/rust-analyzer/src/world.rs b/crates/rust-analyzer/src/world.rs
index 96efab844..6f394055a 100644
--- a/crates/rust-analyzer/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -9,7 +9,6 @@ use std::{
 };
 use crossbeam_channel::{unbounded, Receiver};
-use lsp_server::ErrorCode;
 use lsp_types::Url;
 use parking_lot::RwLock;
 use ra_cargo_watch::{url_from_path_with_drive_lowercasing, CheckOptions, CheckWatcher};
@@ -123,13 +122,12 @@ impl WorldState {
            let vfs_file = vfs.load(path);
            vfs_file.map(|f| FileId(f.0))
        };
-        for ws in workspaces.iter() {
-            let (graph, crate_names) = ws.to_crate_graph(&default_cfg_options, &mut load);
+        workspaces.iter().map(|ws| ws.to_crate_graph(&default_cfg_options, &mut load)).for_each(
-            let shift = crate_graph.extend(graph);
+            |graph| {
-            for (crate_id, name) in crate_names {
+                crate_graph.extend(graph);
-                change.set_debug_crate_name(crate_id.shift(shift), name)
+            },
-            }
+        );
-        }
        change.set_crate_graph(crate_graph);
        // FIXME: Figure out the multi-workspace situation
@@ -252,8 +250,9 @@ impl WorldSnapshot {
        let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?;
        let file = self.vfs.read().path2file(&path).ok_or_else(|| {
            // Show warning as this file is outside current workspace
+            // FIXME: just handle such files, and remove `LspError::UNKNOWN_FILE`.
            LspError {
-                code: ErrorCode::InvalidRequest as i32,
+                code: LspError::UNKNOWN_FILE,
                message: "Rust file outside current workspace is not supported yet.".to_string(),
            }
        })?;