27 files changed, 717 insertions, 362 deletions

diff --git a/crates/hir/src/db.rs b/crates/hir/src/db.rs
index df5758342..ffc8155b9 100644
--- a/crates/hir/src/db.rs
+++ b/crates/hir/src/db.rs
@@ -2,8 +2,8 @@
 
 pub use hir_def::db::*;
 pub use hir_expand::db::{
-    AstDatabase, AstDatabaseStorage, AstIdMapQuery, HygieneFrameQuery, InternEagerExpansionQuery,
-    InternMacroQuery, MacroArgTextQuery, MacroDefQuery, MacroExpandQuery, ParseMacroExpansionQuery,
+    AstDatabase, AstDatabaseStorage, AstIdMapQuery, HygieneFrameQuery, InternMacroQuery,
+    MacroArgTextQuery, MacroDefQuery, MacroExpandQuery, ParseMacroExpansionQuery,
 };
 pub use hir_ty::db::*;
 
diff --git a/crates/hir_def/src/intern.rs b/crates/hir_def/src/intern.rs
index abc304ef0..5cc7f2df6 100644
--- a/crates/hir_def/src/intern.rs
+++ b/crates/hir_def/src/intern.rs
@@ -4,7 +4,7 @@
 
 use std::{
     collections::HashMap,
-    fmt::{self, Debug},
+    fmt::{self, Debug, Display},
     hash::{BuildHasherDefault, Hash, Hasher},
     ops::Deref,
     sync::Arc,
@@ -171,6 +171,12 @@ impl<T: Debug + Internable + ?Sized> Debug for Interned<T> {
     }
 }
 
+impl<T: Display + Internable + ?Sized> Display for Interned<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (*self.arc).fmt(f)
+    }
+}
+
 pub struct InternStorage<T: ?Sized> {
     map: OnceCell<InternMap<T>>,
 }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 19db6cc59..3896be25d 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -21,6 +21,7 @@ use syntax::ast;
 
 use crate::{
     attr::{AttrId, Attrs},
+    builtin_attr,
     db::DefDatabase,
     derive_macro_as_call_id,
     intern::Interned,
@@ -42,7 +43,7 @@ use crate::{
     UnresolvedMacro,
 };
 
-use super::proc_macro::ProcMacroDef;
+use super::proc_macro::{ProcMacroDef, ProcMacroKind};
 
 const GLOB_RECURSION_LIMIT: usize = 100;
 const EXPANSION_DEPTH_LIMIT: usize = 128;
@@ -99,6 +100,8 @@ pub(super) fn collect_defs(
         proc_macros,
         exports_proc_macros: false,
         from_glob_import: Default::default(),
+        ignore_attrs_on: FxHashSet::default(),
+        derive_helpers_in_scope: FxHashMap::default(),
     };
     match block {
         Some(block) => {
@@ -217,6 +220,7 @@ struct MacroDirective {
 enum MacroDirectiveKind {
     FnLike { ast_id: AstIdWithPath<ast::MacroCall>, fragment: FragmentKind },
     Derive { ast_id: AstIdWithPath<ast::Item>, derive_attr: AttrId },
+    Attr { ast_id: AstIdWithPath<ast::Item>, attr: AttrId, mod_item: ModItem },
 }
 
 struct DefData<'a> {
@@ -243,6 +247,10 @@ struct DefCollector<'a> {
     proc_macros: Vec<(Name, ProcMacroExpander)>,
     exports_proc_macros: bool,
     from_glob_import: PerNsGlobImports,
+    ignore_attrs_on: FxHashSet<InFile<ModItem>>,
+    /// Tracks which custom derives are in scope for an item, to allow resolution of derive helper
+    /// attributes.
+    derive_helpers_in_scope: FxHashMap<AstId<ast::Item>, Vec<Name>>,
 }
 
 impl DefCollector<'_> {
@@ -292,16 +300,26 @@ impl DefCollector<'_> {
     fn collect(&mut self) {
         // main name resolution fixed-point loop.
         let mut i = 0;
-        loop {
-            self.db.check_canceled();
-            self.resolve_imports();
+        'outer: loop {
+            loop {
+                self.db.check_canceled();
+                loop {
+                    if self.resolve_imports() == ReachedFixedPoint::Yes {
+                        break;
+                    }
+                }
+                if self.resolve_macros() == ReachedFixedPoint::Yes {
+                    break;
+                }
 
-            match self.resolve_macros() {
-                ReachedFixedPoint::Yes => break,
-                ReachedFixedPoint::No => i += 1,
+                i += 1;
+                if i == FIXED_POINT_LIMIT {
+                    log::error!("name resolution is stuck");
+                    break 'outer;
+                }
             }
-            if i == FIXED_POINT_LIMIT {
-                log::error!("name resolution is stuck");
+
+            if self.reseed_with_unresolved_attributes() == ReachedFixedPoint::Yes {
                 break;
             }
         }
@@ -343,6 +361,54 @@ impl DefCollector<'_> {
         }
     }
 
+    /// When the fixed-point loop reaches a stable state, we might still have some unresolved
+    /// attributes (or unexpanded attribute proc macros) left over. This takes them, and feeds the
+    /// item they're applied to back into name resolution.
+    ///
+    /// This effectively ignores the fact that the macro is there and just treats the items as
+    /// normal code.
+    ///
+    /// This improves UX when proc macros are turned off or don't work, and replicates the behavior
+    /// before we supported proc. attribute macros.
+    fn reseed_with_unresolved_attributes(&mut self) -> ReachedFixedPoint {
+        cov_mark::hit!(unresolved_attribute_fallback);
+
+        let mut added_items = false;
+        let unexpanded_macros = std::mem::replace(&mut self.unexpanded_macros, Vec::new());
+        for directive in &unexpanded_macros {
+            if let MacroDirectiveKind::Attr { ast_id, mod_item, .. } = &directive.kind {
+                // Make sure to only add such items once.
+                if !self.ignore_attrs_on.insert(ast_id.ast_id.with_value(*mod_item)) {
+                    continue;
+                }
+
+                let file_id = self.def_map[directive.module_id].definition_source(self.db).file_id;
+                let item_tree = self.db.file_item_tree(file_id);
+                let mod_dir = self.mod_dirs[&directive.module_id].clone();
+                ModCollector {
+                    def_collector: &mut *self,
+                    macro_depth: directive.depth,
+                    module_id: directive.module_id,
+                    file_id,
+                    item_tree: &item_tree,
+                    mod_dir,
+                }
+                .collect(&[*mod_item]);
+                added_items = true;
+            }
+        }
+
+        // The collection above might add new unresolved macros (eg. derives), so merge the lists.
+        self.unexpanded_macros.extend(unexpanded_macros);
+
+        if added_items {
+            // Continue name resolution with the new data.
+            ReachedFixedPoint::No
+        } else {
+            ReachedFixedPoint::Yes
+        }
+    }
+
     /// Adds a definition of procedural macro `name` to the root module.
     ///
     /// # Notes on procedural macro resolution
@@ -504,35 +570,35 @@ impl DefCollector<'_> {
         }
     }
 
-    /// Import resolution
-    ///
-    /// This is a fix point algorithm. We resolve imports until no forward
-    /// progress in resolving imports is made
-    fn resolve_imports(&mut self) {
-        let mut n_previous_unresolved = self.unresolved_imports.len() + 1;
-
-        while self.unresolved_imports.len() < n_previous_unresolved {
-            n_previous_unresolved = self.unresolved_imports.len();
-            let imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
-            for mut directive in imports {
+    /// Tries to resolve every currently unresolved import.
+    fn resolve_imports(&mut self) -> ReachedFixedPoint {
+        let mut res = ReachedFixedPoint::Yes;
+        let imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
+        let imports = imports
+            .into_iter()
+            .filter_map(|mut directive| {
                 directive.status = self.resolve_import(directive.module_id, &directive.import);
                 match directive.status {
                     PartialResolvedImport::Indeterminate(_) => {
                         self.record_resolved_import(&directive);
                         // FIXME: For avoid performance regression,
                         // we consider an imported resolved if it is indeterminate (i.e not all namespace resolved)
-                        self.resolved_imports.push(directive)
+                        self.resolved_imports.push(directive);
+                        res = ReachedFixedPoint::No;
+                        None
                     }
                     PartialResolvedImport::Resolved(_) => {
                         self.record_resolved_import(&directive);
-                        self.resolved_imports.push(directive)
-                    }
-                    PartialResolvedImport::Unresolved => {
-                        self.unresolved_imports.push(directive);
+                        self.resolved_imports.push(directive);
+                        res = ReachedFixedPoint::No;
+                        None
                     }
+                    PartialResolvedImport::Unresolved => Some(directive),
                 }
-            }
-        }
+            })
+            .collect();
+        self.unresolved_imports = imports;
+        res
     }
 
     fn resolve_import(&self, module_id: LocalModuleId, import: &Import) -> PartialResolvedImport {
@@ -811,6 +877,17 @@ impl DefCollector<'_> {
         let mut resolved = Vec::new();
         let mut res = ReachedFixedPoint::Yes;
         macros.retain(|directive| {
+            let resolver = |path| {
+                let resolved_res = self.def_map.resolve_path_fp_with_macro(
+                    self.db,
+                    ResolveMode::Other,
+                    directive.module_id,
+                    &path,
+                    BuiltinShadowMode::Module,
+                );
+                resolved_res.resolved_def.take_macros()
+            };
+
             match &directive.kind {
                 MacroDirectiveKind::FnLike { ast_id, fragment } => {
                     match macro_call_as_call_id(
@@ -818,16 +895,7 @@ impl DefCollector<'_> {
                         *fragment,
                         self.db,
                         self.def_map.krate,
-                        |path| {
-                            let resolved_res = self.def_map.resolve_path_fp_with_macro(
-                                self.db,
-                                ResolveMode::Other,
-                                directive.module_id,
-                                &path,
-                                BuiltinShadowMode::Module,
-                            );
-                            resolved_res.resolved_def.take_macros()
-                        },
+                        &resolver,
                         &mut |_err| (),
                     ) {
                         Ok(Ok(call_id)) => {
@@ -844,7 +912,7 @@ impl DefCollector<'_> {
                         *derive_attr,
                         self.db,
                         self.def_map.krate,
-                        |path| self.resolve_derive_macro(directive.module_id, &path),
+                        &resolver,
                     ) {
                         Ok(call_id) => {
                             resolved.push((directive.module_id, call_id, directive.depth));
@@ -854,6 +922,9 @@ impl DefCollector<'_> {
                         Err(UnresolvedMacro { .. }) => (),
                     }
                 }
+                MacroDirectiveKind::Attr { .. } => {
+                    // not yet :)
+                }
             }
 
             true
@@ -867,18 +938,6 @@ impl DefCollector<'_> {
         res
     }
 
-    fn resolve_derive_macro(&self, module: LocalModuleId, path: &ModPath) -> Option<MacroDefId> {
-        let resolved_res = self.def_map.resolve_path_fp_with_macro(
-            self.db,
-            ResolveMode::Other,
-            module,
-            &path,
-            BuiltinShadowMode::Module,
-        );
-
-        resolved_res.resolved_def.take_macros()
-    }
-
     fn collect_macro_expansion(
         &mut self,
         module_id: LocalModuleId,
@@ -895,22 +954,33 @@ impl DefCollector<'_> {
         // First, fetch the raw expansion result for purposes of error reporting. This goes through
         // `macro_expand_error` to avoid depending on the full expansion result (to improve
         // incrementality).
+        let loc: MacroCallLoc = self.db.lookup_intern_macro(macro_call_id);
         let err = self.db.macro_expand_error(macro_call_id);
         if let Some(err) = err {
-            if let MacroCallId::LazyMacro(id) = macro_call_id {
-                let loc: MacroCallLoc = self.db.lookup_intern_macro(id);
+            let diag = match err {
+                hir_expand::ExpandError::UnresolvedProcMacro => {
+                    // Missing proc macros are non-fatal, so they are handled specially.
+                    DefDiagnostic::unresolved_proc_macro(module_id, loc.kind.clone())
+                }
+                _ => DefDiagnostic::macro_error(module_id, loc.kind.clone(), err.to_string()),
+            };
 
-                let diag = match err {
-                    hir_expand::ExpandError::UnresolvedProcMacro => {
-                        // Missing proc macros are non-fatal, so they are handled specially.
-                        DefDiagnostic::unresolved_proc_macro(module_id, loc.kind)
-                    }
-                    _ => DefDiagnostic::macro_error(module_id, loc.kind, err.to_string()),
-                };
+            self.def_map.diagnostics.push(diag);
+        }
 
-                self.def_map.diagnostics.push(diag);
+        // If we've just resolved a derive, record its helper attributes.
+        if let MacroCallKind::Derive { ast_id, .. } = &loc.kind {
+            if loc.def.krate != self.def_map.krate {
+                let def_map = self.db.crate_def_map(loc.def.krate);
+                if let Some(def) = def_map.exported_proc_macros.get(&loc.def) {
+                    if let ProcMacroKind::CustomDerive { helpers } = &def.kind {
+                        self.derive_helpers_in_scope
+                            .entry(*ast_id)
+                            .or_default()
+                            .extend(helpers.iter().cloned());
+                    }
+                }
             }
-            // FIXME: Handle eager macros.
         }
 
         // Then, fetch and process the item tree. This will reuse the expansion result from above.
@@ -958,7 +1028,7 @@ impl DefCollector<'_> {
                         ));
                     }
                 },
-                MacroDirectiveKind::Derive { .. } => {
+                MacroDirectiveKind::Derive { .. } | MacroDirectiveKind::Attr { .. } => {
                     // FIXME: we might want to diagnose this too
                 }
             }
@@ -1066,6 +1136,13 @@ impl ModCollector<'_, '_> {
                     continue;
                 }
             }
+
+            if let Err(()) = self.resolve_attributes(&attrs, item) {
+                // Do not process the item. It has at least one non-builtin attribute, so the
+                // fixed-point algorithm is required to resolve the rest of them.
+                continue;
+            }
+
             let module = self.def_collector.def_map.module_id(self.module_id);
 
             let mut def = None;
@@ -1372,6 +1449,62 @@ impl ModCollector<'_, '_> {
         res
     }
 
+    /// Resolves attributes on an item.
+    ///
+    /// Returns `Err` when some attributes could not be resolved to builtins and have been
+    /// registered as unresolved.
+    fn resolve_attributes(&mut self, attrs: &Attrs, mod_item: ModItem) -> Result<(), ()> {
+        fn is_builtin_attr(path: &ModPath) -> bool {
+            if path.kind == PathKind::Plain {
+                if let Some(tool_module) = path.segments().first() {
+                    let tool_module = tool_module.to_string();
+                    if builtin_attr::TOOL_MODULES.iter().any(|m| tool_module == *m) {
+                        return true;
+                    }
+                }
+
+                if let Some(name) = path.as_ident() {
+                    let name = name.to_string();
+                    if builtin_attr::INERT_ATTRIBUTES
+                        .iter()
+                        .chain(builtin_attr::EXTRA_ATTRIBUTES)
+                        .any(|attr| name == *attr)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            false
+        }
+
+        // We failed to resolve an attribute on this item earlier, and are falling back to treating
+        // the item as-is.
+        if self.def_collector.ignore_attrs_on.contains(&InFile::new(self.file_id, mod_item)) {
+            return Ok(());
+        }
+
+        match attrs.iter().find(|attr| !is_builtin_attr(&attr.path)) {
+            Some(non_builtin_attr) => {
+                log::debug!("non-builtin attribute {}", non_builtin_attr.path);
+
+                let ast_id = AstIdWithPath::new(
+                    self.file_id,
+                    mod_item.ast_id(self.item_tree),
+                    non_builtin_attr.path.as_ref().clone(),
+                );
+                self.def_collector.unexpanded_macros.push(MacroDirective {
+                    module_id: self.module_id,
+                    depth: self.macro_depth + 1,
+                    kind: MacroDirectiveKind::Attr { ast_id, attr: non_builtin_attr.id, mod_item },
+                });
+
+                Err(())
+            }
+            None => Ok(()),
+        }
+    }
+
     fn collect_derives(&mut self, attrs: &Attrs, ast_id: FileAstId<ast::Item>) {
         for derive in attrs.by_key("derive").attrs() {
             match derive.parse_derive() {
@@ -1604,6 +1737,8 @@ mod tests {
             proc_macros: Default::default(),
             exports_proc_macros: false,
             from_glob_import: Default::default(),
+            ignore_attrs_on: FxHashSet::default(),
+            derive_helpers_in_scope: FxHashMap::default(),
         };
         collector.seed_with_top_level();
         collector.collect();
diff --git a/crates/hir_def/src/nameres/tests/macros.rs b/crates/hir_def/src/nameres/tests/macros.rs
index c37f915ab..6eb5f97be 100644
--- a/crates/hir_def/src/nameres/tests/macros.rs
+++ b/crates/hir_def/src/nameres/tests/macros.rs
@@ -686,6 +686,56 @@ pub trait Clone {}
 }
 
 #[test]
+fn builtin_derive_with_unresolved_attributes_fall_back() {
+    // Tests that we still resolve derives after ignoring an unresolved attribute.
+    cov_mark::check!(unresolved_attribute_fallback);
+    let map = compute_crate_def_map(
+        r#"
+        //- /main.rs crate:main deps:core
+        use core::Clone;
+
+        #[derive(Clone)]
+        #[unresolved]
+        struct Foo;
+
+        //- /core.rs crate:core
+        #[rustc_builtin_macro]
+        pub macro Clone {}
+        "#,
+    );
+    assert_eq!(map.modules[map.root].scope.impls().len(), 1);
+}
+
+#[test]
+fn unresolved_attributes_fall_back_track_per_file_moditems() {
+    // Tests that we track per-file ModItems when ignoring an unresolved attribute.
+    // Just tracking the `ModItem` leads to `Foo` getting ignored.
+
+    check(
+        r#"
+        //- /main.rs crate:main
+
+        mod submod;
+
+        #[unresolved]
+        struct Foo;
+
+        //- /submod.rs
+        #[unresolved]
+        struct Bar;
+        "#,
+        expect![[r#"
+            crate
+            Foo: t v
+            submod: t
+
+            crate::submod
+            Bar: t v
+        "#]],
+    );
+}
+
+#[test]
 fn macro_expansion_overflow() {
     cov_mark::check!(macro_expansion_overflow);
     check(
@@ -842,7 +892,6 @@ fn collects_derive_helpers() {
 fn resolve_macro_def() {
     check(
         r#"
-//- /lib.rs
 pub macro structs($($i:ident),*) {
     $(struct $i { field: u32 } )*
 }
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index b6a6d602f..fe9497b50 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -8,7 +8,7 @@ use syntax::{
     match_ast,
 };
 
-use crate::{db::AstDatabase, name, quote, AstId, CrateId, LazyMacroId, MacroDefId, MacroDefKind};
+use crate::{db::AstDatabase, name, quote, AstId, CrateId, MacroCallId, MacroDefId, MacroDefKind};
 
 macro_rules! register_builtin {
     ( $($trait:ident => $expand:ident),* ) => {
@@ -21,7 +21,7 @@ macro_rules! register_builtin {
             pub fn expand(
                 &self,
                 db: &dyn AstDatabase,
-                id: LazyMacroId,
+                id: MacroCallId,
                 tt: &tt::Subtree,
             ) -> Result<tt::Subtree, mbe::ExpandError> {
                 let expander = match *self {
@@ -164,7 +164,7 @@ fn expand_simple_derive(
     Ok(expanded)
 }
 
-fn find_builtin_crate(db: &dyn AstDatabase, id: LazyMacroId) -> tt::TokenTree {
+fn find_builtin_crate(db: &dyn AstDatabase, id: MacroCallId) -> tt::TokenTree {
     // FIXME: make hygiene works for builtin derive macro
     // such that $crate can be used here.
     let cg = db.crate_graph();
@@ -184,7 +184,7 @@ fn find_builtin_crate(db: &dyn AstDatabase, id: LazyMacroId) -> tt::TokenTree {
 
 fn copy_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
     let krate = find_builtin_crate(db, id);
@@ -193,7 +193,7 @@ fn copy_expand(
 
 fn clone_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
     let krate = find_builtin_crate(db, id);
@@ -202,7 +202,7 @@ fn clone_expand(
 
 fn default_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
     let krate = find_builtin_crate(db, id);
@@ -211,7 +211,7 @@ fn default_expand(
 
 fn debug_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
     let krate = find_builtin_crate(db, id);
@@ -220,7 +220,7 @@ fn debug_expand(
 
 fn hash_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
     let krate = find_builtin_crate(db, id);
@@ -229,7 +229,7 @@ fn hash_expand(
 
 fn eq_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
     let krate = find_builtin_crate(db, id);
@@ -238,7 +238,7 @@ fn eq_expand(
 
 fn partial_eq_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
     let krate = find_builtin_crate(db, id);
@@ -247,7 +247,7 @@ fn partial_eq_expand(
 
 fn ord_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
     let krate = find_builtin_crate(db, id);
@@ -256,7 +256,7 @@ fn ord_expand(
 
 fn partial_ord_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
     let krate = find_builtin_crate(db, id);
@@ -317,6 +317,7 @@ $0
                 local_inner: false,
             },
             krate: CrateId(0),
+            eager: None,
             kind: MacroCallKind::Derive {
                 ast_id,
                 derive_name: name.to_string(),
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 280c25f11..94d7aecb6 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -1,7 +1,7 @@
 //! Builtin macro
 use crate::{
-    db::AstDatabase, name, quote, AstId, CrateId, EagerMacroId, LazyMacroId, MacroCallId,
-    MacroCallLoc, MacroDefId, MacroDefKind, TextSize,
+    db::AstDatabase, name, quote, AstId, CrateId, MacroCallId, MacroCallLoc, MacroDefId,
+    MacroDefKind, TextSize,
 };
 
 use base_db::{AnchoredPath, Edition, FileId};
@@ -27,7 +27,7 @@ macro_rules! register_builtin {
             pub fn expand(
                 &self,
                 db: &dyn AstDatabase,
-                id: LazyMacroId,
+                id: MacroCallId,
                 tt: &tt::Subtree,
             ) -> ExpandResult<tt::Subtree> {
                 let expander = match *self {
@@ -41,7 +41,7 @@ macro_rules! register_builtin {
             pub fn expand(
                 &self,
                 db: &dyn AstDatabase,
-                arg_id: EagerMacroId,
+                arg_id: MacroCallId,
                 tt: &tt::Subtree,
             ) -> ExpandResult<Option<ExpandedEager>> {
                 let expander = match *self {
@@ -128,7 +128,7 @@ register_builtin! {
 
 fn module_path_expand(
     _db: &dyn AstDatabase,
-    _id: LazyMacroId,
+    _id: MacroCallId,
     _tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     // Just return a dummy result.
@@ -137,7 +137,7 @@ fn module_path_expand(
 
 fn line_expand(
     _db: &dyn AstDatabase,
-    _id: LazyMacroId,
+    _id: MacroCallId,
     _tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     // dummy implementation for type-checking purposes
@@ -151,7 +151,7 @@ fn line_expand(
 
 fn stringify_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     _tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     let loc = db.lookup_intern_macro(id);
@@ -176,7 +176,7 @@ fn stringify_expand(
 
 fn column_expand(
     _db: &dyn AstDatabase,
-    _id: LazyMacroId,
+    _id: MacroCallId,
     _tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     // dummy implementation for type-checking purposes
@@ -190,7 +190,7 @@ fn column_expand(
 
 fn assert_expand(
     _db: &dyn AstDatabase,
-    _id: LazyMacroId,
+    _id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     // A hacky implementation for goto def and hover
@@ -214,7 +214,7 @@ fn assert_expand(
 
 fn file_expand(
     _db: &dyn AstDatabase,
-    _id: LazyMacroId,
+    _id: MacroCallId,
     _tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     // FIXME: RA purposefully lacks knowledge of absolute file names
@@ -230,7 +230,7 @@ fn file_expand(
 
 fn format_args_expand(
     _db: &dyn AstDatabase,
-    _id: LazyMacroId,
+    _id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     // We expand `format_args!("", a1, a2)` to
@@ -265,7 +265,7 @@ fn format_args_expand(
 
 fn asm_expand(
     _db: &dyn AstDatabase,
-    _id: LazyMacroId,
+    _id: MacroCallId,
     _tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     // both asm and llvm_asm don't return anything, so we can expand them to nothing,
@@ -278,7 +278,7 @@ fn asm_expand(
 
 fn global_asm_expand(
     _db: &dyn AstDatabase,
-    _id: LazyMacroId,
+    _id: MacroCallId,
     _tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     // Expand to nothing (at item-level)
@@ -287,7 +287,7 @@ fn global_asm_expand(
 
 fn cfg_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     let loc = db.lookup_intern_macro(id);
@@ -299,7 +299,7 @@ fn cfg_expand(
 
 fn panic_expand(
     db: &dyn AstDatabase,
-    id: LazyMacroId,
+    id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<tt::Subtree> {
     let loc: MacroCallLoc = db.lookup_intern_macro(id);
@@ -324,7 +324,7 @@ fn unquote_str(lit: &tt::Literal) -> Option<String> {
 
 fn compile_error_expand(
     _db: &dyn AstDatabase,
-    _id: EagerMacroId,
+    _id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<Option<ExpandedEager>> {
     let err = match &*tt.token_trees {
@@ -345,7 +345,7 @@ fn compile_error_expand(
 
 fn concat_expand(
     _db: &dyn AstDatabase,
-    _arg_id: EagerMacroId,
+    _arg_id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<Option<ExpandedEager>> {
     let mut err = None;
@@ -376,7 +376,7 @@ fn concat_expand(
 
 fn concat_idents_expand(
     _db: &dyn AstDatabase,
-    _arg_id: EagerMacroId,
+    _arg_id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<Option<ExpandedEager>> {
     let mut err = None;
@@ -427,7 +427,7 @@ fn parse_string(tt: &tt::Subtree) -> Result<String, mbe::ExpandError> {
 
 fn include_expand(
     db: &dyn AstDatabase,
-    arg_id: EagerMacroId,
+    arg_id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<Option<ExpandedEager>> {
     let res = (|| {
@@ -457,7 +457,7 @@ fn include_expand(
 
 fn include_bytes_expand(
     _db: &dyn AstDatabase,
-    _arg_id: EagerMacroId,
+    _arg_id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<Option<ExpandedEager>> {
     if let Err(e) = parse_string(tt) {
@@ -477,7 +477,7 @@ fn include_bytes_expand(
 
 fn include_str_expand(
     db: &dyn AstDatabase,
-    arg_id: EagerMacroId,
+    arg_id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<Option<ExpandedEager>> {
     let path = match parse_string(tt) {
@@ -502,14 +502,14 @@ fn include_str_expand(
     ExpandResult::ok(Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)))
 }
 
-fn get_env_inner(db: &dyn AstDatabase, arg_id: EagerMacroId, key: &str) -> Option<String> {
-    let krate = db.lookup_intern_eager_expansion(arg_id).krate;
+fn get_env_inner(db: &dyn AstDatabase, arg_id: MacroCallId, key: &str) -> Option<String> {
+    let krate = db.lookup_intern_macro(arg_id).krate;
     db.crate_graph()[krate].env.get(key)
 }
 
 fn env_expand(
     db: &dyn AstDatabase,
-    arg_id: EagerMacroId,
+    arg_id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<Option<ExpandedEager>> {
     let key = match parse_string(tt) {
@@ -540,7 +540,7 @@ fn env_expand(
 
 fn option_env_expand(
     db: &dyn AstDatabase,
-    arg_id: EagerMacroId,
+    arg_id: MacroCallId,
     tt: &tt::Subtree,
 ) -> ExpandResult<Option<ExpandedEager>> {
     let key = match parse_string(tt) {
@@ -560,7 +560,7 @@ fn option_env_expand(
 mod tests {
     use super::*;
     use crate::{
-        name::AsName, test_db::TestDB, AstNode, EagerCallLoc, MacroCallId, MacroCallKind,
+        name::AsName, test_db::TestDB, AstNode, EagerCallInfo, MacroCallId, MacroCallKind,
         MacroCallLoc,
     };
     use base_db::{fixture::WithFixture, SourceDatabase};
@@ -599,6 +599,7 @@ mod tests {
                 let loc = MacroCallLoc {
                     def,
                     krate,
+                    eager: None,
                     kind: MacroCallKind::FnLike {
                         ast_id: AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call)),
                         fragment: FragmentKind::Expr,
@@ -620,28 +621,28 @@ mod tests {
                 let parsed_args = mbe::ast_to_token_tree(&args).0;
                 let call_id = AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call));
 
-                let arg_id = db.intern_eager_expansion({
-                    EagerCallLoc {
-                        def,
-                        fragment: FragmentKind::Expr,
-                        subtree: Arc::new(parsed_args.clone()),
-                        krate,
-                        call: call_id,
+                let arg_id = db.intern_macro(MacroCallLoc {
+                    def,
+                    krate,
+                    eager: Some(EagerCallInfo {
+                        arg_or_expansion: Arc::new(parsed_args.clone()),
                         included_file: None,
-                    }
+                    }),
+                    kind: MacroCallKind::FnLike { ast_id: call_id, fragment: FragmentKind::Expr },
                 });
 
                 let expanded = expander.expand(&db, arg_id, &parsed_args).value.unwrap();
-                let eager = EagerCallLoc {
+                let loc = MacroCallLoc {
                     def,
-                    fragment: expanded.fragment,
-                    subtree: Arc::new(expanded.subtree),
                     krate,
-                    call: call_id,
-                    included_file: expanded.included_file,
+                    eager: Some(EagerCallInfo {
+                        arg_or_expansion: Arc::new(expanded.subtree),
+                        included_file: expanded.included_file,
+                    }),
+                    kind: MacroCallKind::FnLike { ast_id: call_id, fragment: expanded.fragment },
                 };
 
-                let id: MacroCallId = db.intern_eager_expansion(eager).into();
+                let id: MacroCallId = db.intern_macro(loc).into();
                 id.as_file()
             }
         };
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index c43d382ad..5c769c1bf 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -13,8 +13,8 @@ use syntax::{
 
 use crate::{
     ast_id_map::AstIdMap, hygiene::HygieneFrame, input::process_macro_input, BuiltinDeriveExpander,
-    BuiltinFnLikeExpander, EagerCallLoc, EagerMacroId, HirFileId, HirFileIdRepr, LazyMacroId,
-    MacroCallId, MacroCallLoc, MacroDefId, MacroDefKind, MacroFile, ProcMacroExpander,
+    BuiltinFnLikeExpander, HirFileId, HirFileIdRepr, MacroCallId, MacroCallLoc, MacroDefId,
+    MacroDefKind, MacroFile, ProcMacroExpander,
 };
 
 /// Total limit on the number of tokens produced by any macro invocation.
@@ -41,7 +41,7 @@ impl TokenExpander {
     fn expand(
         &self,
         db: &dyn AstDatabase,
-        id: LazyMacroId,
+        id: MacroCallId,
         tt: &tt::Subtree,
     ) -> mbe::ExpandResult<tt::Subtree> {
         match self {
@@ -101,11 +101,7 @@ pub trait AstDatabase: SourceDatabase {
     /// We encode macro definitions into ids of macro calls, this what allows us
     /// to be incremental.
     #[salsa::interned]
-    fn intern_macro(&self, macro_call: MacroCallLoc) -> LazyMacroId;
-    /// Certain built-in macros are eager (`format!(concat!("file: ", file!(), "{}"")), 92`).
-    /// For them, we actually want to encode the whole token tree as an argument.
-    #[salsa::interned]
-    fn intern_eager_expansion(&self, eager: EagerCallLoc) -> EagerMacroId;
+    fn intern_macro(&self, macro_call: MacroCallLoc) -> MacroCallId;
 
     /// Lowers syntactic macro call to a token tree representation.
     #[salsa::transparent]
@@ -146,17 +142,12 @@ pub fn expand_hypothetical(
         token_to_map.text_range().checked_sub(hypothetical_args.syntax().text_range().start())?;
     let token_id = tmap_1.token_by_range(range)?;
 
-    let lazy_id = match actual_macro_call {
-        MacroCallId::LazyMacro(id) => id,
-        MacroCallId::EagerMacro(_) => return None,
-    };
-
     let macro_def = {
-        let loc = db.lookup_intern_macro(lazy_id);
+        let loc: MacroCallLoc = db.lookup_intern_macro(actual_macro_call);
         db.macro_def(loc.def)?
     };
 
-    let hypothetical_expansion = macro_def.expand(db, lazy_id, &tt);
+    let hypothetical_expansion = macro_def.expand(db, actual_macro_call, &tt);
 
     let fragment_kind = macro_fragment_kind(db, actual_macro_call);
 
@@ -194,30 +185,22 @@ fn parse_macro_expansion(
         // Note:
         // The final goal we would like to make all parse_macro success,
         // such that the following log will not call anyway.
-        match macro_file.macro_call_id {
-            MacroCallId::LazyMacro(id) => {
-                let loc: MacroCallLoc = db.lookup_intern_macro(id);
-                let node = loc.kind.node(db);
-
-                // collect parent information for warning log
-                let parents = std::iter::successors(loc.kind.file_id().call_node(db), |it| {
-                    it.file_id.call_node(db)
-                })
+        let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
+        let node = loc.kind.node(db);
+
+        // collect parent information for warning log
+        let parents =
+            std::iter::successors(loc.kind.file_id().call_node(db), |it| it.file_id.call_node(db))
                 .map(|n| format!("{:#}", n.value))
                 .collect::<Vec<_>>()
                 .join("\n");
 
-                log::warn!(
-                    "fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}",
-                    err,
-                    node.value,
-                    parents
-                );
-            }
-            _ => {
-                log::warn!("fail on macro_parse: (reason: {:?})", err);
-            }
-        }
+        log::warn!(
+            "fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}",
+            err,
+            node.value,
+            parents
+        );
     }
     let tt = match result.value {
         Some(tt) => tt,
@@ -269,25 +252,16 @@ fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree,
     let arg = db.macro_arg_text(id)?;
     let (mut tt, tmap) = mbe::syntax_node_to_token_tree(&SyntaxNode::new_root(arg));
 
-    if let MacroCallId::LazyMacro(id) = id {
-        let loc: MacroCallLoc = db.lookup_intern_macro(id);
-        if loc.def.is_proc_macro() {
-            // proc macros expect their inputs without parentheses, MBEs expect it with them included
-            tt.delimiter = None;
-        }
+    let loc: MacroCallLoc = db.lookup_intern_macro(id);
+    if loc.def.is_proc_macro() {
+        // proc macros expect their inputs without parentheses, MBEs expect it with them included
+        tt.delimiter = None;
     }
 
     Some(Arc::new((tt, tmap)))
 }
 
 fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
-    let id = match id {
-        MacroCallId::LazyMacro(id) => id,
-        MacroCallId::EagerMacro(_id) => {
-            // FIXME: support macro_arg for eager macro
-            return None;
-        }
-    };
     let loc = db.lookup_intern_macro(id);
     let arg = loc.kind.arg(db)?;
     let arg = process_macro_input(db, arg, id);
@@ -347,24 +321,21 @@ fn macro_expand_with_arg(
     arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
 ) -> ExpandResult<Option<Arc<tt::Subtree>>> {
     let _p = profile::span("macro_expand");
-    let lazy_id = match id {
-        MacroCallId::LazyMacro(id) => id,
-        MacroCallId::EagerMacro(id) => {
-            if arg.is_some() {
-                return ExpandResult::str_err(
-                    "hypothetical macro expansion not implemented for eager macro".to_owned(),
-                );
-            } else {
-                return ExpandResult {
-                    value: Some(db.lookup_intern_eager_expansion(id).subtree),
-                    // FIXME: There could be errors here!
-                    err: None,
-                };
-            }
+    let loc: MacroCallLoc = db.lookup_intern_macro(id);
+    if let Some(eager) = &loc.eager {
+        if arg.is_some() {
+            return ExpandResult::str_err(
+                "hypothetical macro expansion not implemented for eager macro".to_owned(),
+            );
+        } else {
+            return ExpandResult {
+                value: Some(eager.arg_or_expansion.clone()),
+                // FIXME: There could be errors here!
+                err: None,
+            };
         }
-    };
+    }
 
-    let loc = db.lookup_intern_macro(lazy_id);
     let macro_arg = match arg.or_else(|| db.macro_arg(id)) {
         Some(it) => it,
         None => return ExpandResult::str_err("Fail to args in to tt::TokenTree".into()),
@@ -374,7 +345,7 @@ fn macro_expand_with_arg(
         Some(it) => it,
         None => return ExpandResult::str_err("Fail to find macro definition".into()),
     };
-    let ExpandResult { value: tt, err } = macro_rules.expand(db, lazy_id, &macro_arg.0);
+    let ExpandResult { value: tt, err } = macro_rules.expand(db, id, &macro_arg.0);
     // Set a hard limit for the expanded tt
     let count = tt.count();
     if count > TOKEN_LIMIT {
@@ -391,12 +362,7 @@ fn expand_proc_macro(
     db: &dyn AstDatabase,
     id: MacroCallId,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
-    let lazy_id = match id {
-        MacroCallId::LazyMacro(id) => id,
-        MacroCallId::EagerMacro(_) => unreachable!(),
-    };
-
-    let loc = db.lookup_intern_macro(lazy_id);
+    let loc: MacroCallLoc = db.lookup_intern_macro(id);
     let macro_arg = match db.macro_arg(id) {
         Some(it) => it,
         None => {
@@ -436,14 +402,6 @@ fn hygiene_frame(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<HygieneFrame>
 }
 
 fn macro_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
-    match id {
-        MacroCallId::LazyMacro(id) => {
-            let loc: MacroCallLoc = db.lookup_intern_macro(id);
-            loc.kind.fragment_kind()
-        }
-        MacroCallId::EagerMacro(id) => {
-            let loc: EagerCallLoc = db.lookup_intern_eager_expansion(id);
-            loc.fragment
-        }
-    }
+    let loc: MacroCallLoc = db.lookup_intern_macro(id);
+    loc.kind.fragment_kind()
 }
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 85491fe8b..e165b9c5f 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -22,7 +22,7 @@
 use crate::{
     ast::{self, AstNode},
     db::AstDatabase,
-    EagerCallLoc, EagerMacroId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
+    EagerCallInfo, InFile, MacroCallId, MacroCallKind, MacroCallLoc, MacroDefId, MacroDefKind,
 };
 
 use base_db::CrateId;
@@ -105,7 +105,7 @@ pub fn expand_eager_macro(
     def: MacroDefId,
     resolver: &dyn Fn(ast::Path) -> Option<MacroDefId>,
     mut diagnostic_sink: &mut dyn FnMut(mbe::ExpandError),
-) -> Result<EagerMacroId, ErrorEmitted> {
+) -> Result<MacroCallId, ErrorEmitted> {
     let parsed_args = diagnostic_sink.option_with(
         || Some(mbe::ast_to_token_tree(&macro_call.value.token_tree()?).0),
         || err("malformed macro invocation"),
@@ -118,15 +118,14 @@ pub fn expand_eager_macro(
     // When `lazy_expand` is called, its *parent* file must be already exists.
     // Here we store an eager macro id for the argument expanded subtree here
     // for that purpose.
-    let arg_id = db.intern_eager_expansion({
-        EagerCallLoc {
-            def,
-            fragment: FragmentKind::Expr,
-            subtree: Arc::new(parsed_args.clone()),
-            krate,
-            call: call_id,
+    let arg_id = db.intern_macro(MacroCallLoc {
+        def,
+        krate,
+        eager: Some(EagerCallInfo {
+            arg_or_expansion: Arc::new(parsed_args.clone()),
             included_file: None,
-        }
+        }),
+        kind: MacroCallKind::FnLike { ast_id: call_id, fragment: FragmentKind::Expr },
     });
     let arg_file_id: MacroCallId = arg_id.into();
 
@@ -146,16 +145,17 @@ pub fn expand_eager_macro(
         let res = eager.expand(db, arg_id, &subtree);
 
         let expanded = diagnostic_sink.expand_result_option(res)?;
-        let eager = EagerCallLoc {
+        let loc = MacroCallLoc {
             def,
-            fragment: expanded.fragment,
-            subtree: Arc::new(expanded.subtree),
             krate,
-            call: call_id,
-            included_file: expanded.included_file,
+            eager: Some(EagerCallInfo {
+                arg_or_expansion: Arc::new(expanded.subtree),
+                included_file: expanded.included_file,
+            }),
+            kind: MacroCallKind::FnLike { ast_id: call_id, fragment: expanded.fragment },
         };
 
-        Ok(db.intern_eager_expansion(eager))
+        Ok(db.intern_macro(loc))
     } else {
         panic!("called `expand_eager_macro` on non-eager macro def {:?}", def);
     }
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index aca69e35a..38e09fdd4 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -14,7 +14,7 @@ use syntax::{ast, AstNode, SyntaxNode, TextRange, TextSize};
 use crate::{
     db::{self, AstDatabase},
     name::{AsName, Name},
-    HirFileId, HirFileIdRepr, InFile, MacroCallId, MacroCallLoc, MacroDefKind, MacroFile,
+    HirFileId, HirFileIdRepr, InFile, MacroCallLoc, MacroDefKind, MacroFile,
 };
 
 #[derive(Clone, Debug)]
@@ -140,10 +140,7 @@ impl HygieneInfo {
         let (token_id, origin) = self.macro_def.map_id_up(token_id);
         let (token_map, tt) = match origin {
             mbe::Origin::Call => {
-                let call_id = match self.file.macro_call_id {
-                    MacroCallId::LazyMacro(lazy) => lazy,
-                    MacroCallId::EagerMacro(_) => unreachable!(),
-                };
+                let call_id = self.file.macro_call_id;
                 let loc: MacroCallLoc = db.lookup_intern_macro(call_id);
                 let arg_start = loc.kind.arg(db)?.text_range().start();
                 (&self.macro_arg.1, InFile::new(loc.kind.file_id(), arg_start))
@@ -186,23 +183,20 @@ impl HygieneFrame {
     pub(crate) fn new(db: &dyn AstDatabase, file_id: HirFileId) -> HygieneFrame {
         let (info, krate, local_inner) = match file_id.0 {
             HirFileIdRepr::FileId(_) => (None, None, false),
-            HirFileIdRepr::MacroFile(macro_file) => match macro_file.macro_call_id {
-                MacroCallId::EagerMacro(_id) => (None, None, false),
-                MacroCallId::LazyMacro(id) => {
-                    let loc = db.lookup_intern_macro(id);
-                    let info = make_hygiene_info(db, macro_file, &loc)
-                        .map(|info| (loc.kind.file_id(), info));
-                    match loc.def.kind {
-                        MacroDefKind::Declarative(_) => {
-                            (info, Some(loc.def.krate), loc.def.local_inner)
-                        }
-                        MacroDefKind::BuiltIn(..) => (info, Some(loc.def.krate), false),
-                        MacroDefKind::BuiltInDerive(..) => (info, None, false),
-                        MacroDefKind::BuiltInEager(..) => (info, None, false),
-                        MacroDefKind::ProcMacro(..) => (info, None, false),
+            HirFileIdRepr::MacroFile(macro_file) => {
+                let loc = db.lookup_intern_macro(macro_file.macro_call_id);
+                let info =
+                    make_hygiene_info(db, macro_file, &loc).map(|info| (loc.kind.file_id(), info));
+                match loc.def.kind {
+                    MacroDefKind::Declarative(_) => {
+                        (info, Some(loc.def.krate), loc.def.local_inner)
                     }
+                    MacroDefKind::BuiltIn(..) => (info, Some(loc.def.krate), false),
+                    MacroDefKind::BuiltInDerive(..) => (info, None, false),
+                    MacroDefKind::BuiltInEager(..) => (info, None, false),
+                    MacroDefKind::ProcMacro(..) => (info, None, false),
                 }
-            },
+            }
         };
 
         let (calling_file, info) = match info {
diff --git a/crates/hir_expand/src/input.rs b/crates/hir_expand/src/input.rs
index 112216859..fe4790e7b 100644
--- a/crates/hir_expand/src/input.rs
+++ b/crates/hir_expand/src/input.rs
@@ -8,13 +8,13 @@ use syntax::{
 use crate::{
     db::AstDatabase,
     name::{name, AsName},
-    LazyMacroId, MacroCallKind, MacroCallLoc,
+    MacroCallId, MacroCallKind, MacroCallLoc,
 };
 
 pub(crate) fn process_macro_input(
     db: &dyn AstDatabase,
     node: SyntaxNode,
-    id: LazyMacroId,
+    id: MacroCallId,
 ) -> SyntaxNode {
     let loc: MacroCallLoc = db.lookup_intern_macro(id);
 
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 88cb16ca4..92c679dd2 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -80,19 +80,10 @@ impl HirFileId {
         match self.0 {
             HirFileIdRepr::FileId(file_id) => file_id,
             HirFileIdRepr::MacroFile(macro_file) => {
-                let file_id = match macro_file.macro_call_id {
-                    MacroCallId::LazyMacro(id) => {
-                        let loc = db.lookup_intern_macro(id);
-                        loc.kind.file_id()
-                    }
-                    MacroCallId::EagerMacro(id) => {
-                        let loc = db.lookup_intern_eager_expansion(id);
-                        if let Some(included_file) = loc.included_file {
-                            return included_file;
-                        } else {
-                            loc.call.file_id
-                        }
-                    }
+                let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
+                let file_id = match &loc.eager {
+                    Some(EagerCallInfo { included_file: Some(file), .. }) => (*file).into(),
+                    _ => loc.kind.file_id(),
                 };
                 file_id.original_file(db)
             }
@@ -103,17 +94,10 @@ impl HirFileId {
         let mut level = 0;
         let mut curr = self;
         while let HirFileIdRepr::MacroFile(macro_file) = curr.0 {
+            let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
+
             level += 1;
-            curr = match macro_file.macro_call_id {
-                MacroCallId::LazyMacro(id) => {
-                    let loc = db.lookup_intern_macro(id);
-                    loc.kind.file_id()
-                }
-                MacroCallId::EagerMacro(id) => {
-                    let loc = db.lookup_intern_eager_expansion(id);
-                    loc.call.file_id
-                }
-            };
+            curr = loc.kind.file_id();
         }
         level
     }
@@ -122,16 +106,10 @@ impl HirFileId {
     pub fn call_node(self, db: &dyn db::AstDatabase) -> Option<InFile<SyntaxNode>> {
         match self.0 {
             HirFileIdRepr::FileId(_) => None,
-            HirFileIdRepr::MacroFile(macro_file) => match macro_file.macro_call_id {
-                MacroCallId::LazyMacro(lazy_id) => {
-                    let loc: MacroCallLoc = db.lookup_intern_macro(lazy_id);
-                    Some(loc.kind.node(db))
-                }
-                MacroCallId::EagerMacro(id) => {
-                    let loc: EagerCallLoc = db.lookup_intern_eager_expansion(id);
-                    Some(loc.call.with_value(loc.call.to_node(db).syntax().clone()))
-                }
-            },
+            HirFileIdRepr::MacroFile(macro_file) => {
+                let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
+                Some(loc.kind.node(db))
+            }
         }
     }
 
@@ -140,14 +118,7 @@ impl HirFileId {
         match self.0 {
             HirFileIdRepr::FileId(_) => None,
             HirFileIdRepr::MacroFile(macro_file) => {
-                let lazy_id = match macro_file.macro_call_id {
-                    MacroCallId::LazyMacro(id) => id,
-                    MacroCallId::EagerMacro(_id) => {
-                        // FIXME: handle expansion_info for eager macro
-                        return None;
-                    }
-                };
-                let loc: MacroCallLoc = db.lookup_intern_macro(lazy_id);
+                let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
 
                 let arg_tt = loc.kind.arg(db)?;
 
@@ -180,13 +151,7 @@ impl HirFileId {
         match self.0 {
             HirFileIdRepr::FileId(_) => None,
             HirFileIdRepr::MacroFile(macro_file) => {
-                let lazy_id = match macro_file.macro_call_id {
-                    MacroCallId::LazyMacro(id) => id,
-                    MacroCallId::EagerMacro(_id) => {
-                        return None;
-                    }
-                };
-                let loc: MacroCallLoc = db.lookup_intern_macro(lazy_id);
+                let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
                 let item = match loc.def.kind {
                     MacroDefKind::BuiltInDerive(..) => loc.kind.node(db),
                     _ => return None,
@@ -199,16 +164,12 @@ impl HirFileId {
     /// Return whether this file is an include macro
     pub fn is_include_macro(&self, db: &dyn db::AstDatabase) -> bool {
         match self.0 {
-            HirFileIdRepr::MacroFile(macro_file) => match macro_file.macro_call_id {
-                MacroCallId::EagerMacro(id) => {
-                    let loc = db.lookup_intern_eager_expansion(id);
-                    return loc.included_file.is_some();
-                }
-                _ => {}
-            },
-            _ => {}
+            HirFileIdRepr::MacroFile(macro_file) => {
+                let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
+                matches!(loc.eager, Some(EagerCallInfo { included_file: Some(_), .. }))
+            }
+            _ => false,
         }
-        false
     }
 }
 
@@ -220,29 +181,8 @@ pub struct MacroFile {
 /// `MacroCallId` identifies a particular macro invocation, like
 /// `println!("Hello, {}", world)`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum MacroCallId {
-    LazyMacro(LazyMacroId),
-    EagerMacro(EagerMacroId),
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct LazyMacroId(salsa::InternId);
-impl_intern_key!(LazyMacroId);
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct EagerMacroId(salsa::InternId);
-impl_intern_key!(EagerMacroId);
-
-impl From<LazyMacroId> for MacroCallId {
-    fn from(it: LazyMacroId) -> Self {
-        MacroCallId::LazyMacro(it)
-    }
-}
-impl From<EagerMacroId> for MacroCallId {
-    fn from(it: EagerMacroId) -> Self {
-        MacroCallId::EagerMacro(it)
-    }
-}
+pub struct MacroCallId(salsa::InternId);
+impl_intern_key!(MacroCallId);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct MacroDefId {
@@ -258,8 +198,8 @@ impl MacroDefId {
         db: &dyn db::AstDatabase,
         krate: CrateId,
         kind: MacroCallKind,
-    ) -> LazyMacroId {
-        db.intern_macro(MacroCallLoc { def: self, krate, kind })
+    ) -> MacroCallId {
+        db.intern_macro(MacroCallLoc { def: self, krate, eager: None, kind })
     }
 
     pub fn ast_id(&self) -> Either<AstId<ast::Macro>, AstId<ast::Fn>> {
@@ -289,9 +229,17 @@ pub enum MacroDefKind {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct EagerCallInfo {
+    /// NOTE: This can be *either* the expansion result, *or* the argument to the eager macro!
+    arg_or_expansion: Arc<tt::Subtree>,
+    included_file: Option<FileId>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MacroCallLoc {
-    pub(crate) def: MacroDefId,
+    pub def: MacroDefId,
     pub(crate) krate: CrateId,
+    eager: Option<EagerCallInfo>,
     pub kind: MacroCallKind,
 }
 
@@ -313,6 +261,7 @@ pub enum MacroCallKind {
 }
 
 impl MacroCallKind {
+    /// Returns the file containing the macro invocation.
     fn file_id(&self) -> HirFileId {
         match self {
             MacroCallKind::FnLike { ast_id, .. } => ast_id.file_id,
@@ -354,17 +303,6 @@ impl MacroCallId {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct EagerCallLoc {
-    pub(crate) def: MacroDefId,
-    pub(crate) fragment: FragmentKind,
-    pub(crate) subtree: Arc<tt::Subtree>,
-    pub(crate) krate: CrateId,
-    pub(crate) call: AstId<ast::MacroCall>,
-    // The included file ID of the include macro.
-    pub(crate) included_file: Option<FileId>,
-}
-
 /// ExpansionInfo mainly describes how to map text range between src and expanded macro
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ExpansionInfo {
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 47709c1e8..b9a69b79c 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -211,7 +211,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
 
         // FIXME: Due to shortcomings in the current type system implementation, only emit this
         // diagnostic if there are no type mismatches in the containing function.
-        if self.infer.type_mismatches.iter().next().is_some() {
+        if self.infer.expr_type_mismatches().next().is_some() {
             return;
         }
 
@@ -311,11 +311,12 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                 // necessary.
                 //
                 // FIXME we should use the type checker for this.
-                if pat_ty == match_expr_ty
+                if (pat_ty == match_expr_ty
                     || match_expr_ty
                         .as_reference()
                         .map(|(match_expr_ty, ..)| match_expr_ty == pat_ty)
-                        .unwrap_or(false)
+                        .unwrap_or(false))
+                    && types_of_subpatterns_do_match(pat, &cx.body, &infer)
                 {
                     // If we had a NotUsefulMatchArm diagnostic, we could
                     // check the usefulness of each pattern as we added it
@@ -496,6 +497,21 @@ pub fn record_pattern_missing_fields(
     Some((variant_def, missed_fields, exhaustive))
 }
 
+fn types_of_subpatterns_do_match(pat: PatId, body: &Body, infer: &InferenceResult) -> bool {
+    fn walk(pat: PatId, body: &Body, infer: &InferenceResult, has_type_mismatches: &mut bool) {
+        match infer.type_mismatch_for_pat(pat) {
+            Some(_) => *has_type_mismatches = true,
+            None => {
+                body[pat].walk_child_pats(|subpat| walk(subpat, body, infer, has_type_mismatches))
+            }
+        }
+    }
+
+    let mut has_type_mismatches = false;
+    walk(pat, body, infer, &mut has_type_mismatches);
+    !has_type_mismatches
+}
+
 #[cfg(test)]
 mod tests {
     use crate::diagnostics::tests::check_diagnostics;
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index 6ee0529c6..e8dd669bf 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -1128,6 +1128,18 @@ fn main() {
     }
 
     #[test]
+    fn mismatched_types_in_or_patterns() {
+        check_diagnostics(
+            r#"
+fn main() {
+    match false { true | () => {} }
+    match (false,) { (true | (),) => {} }
+}
+"#,
+        );
+    }
+
+    #[test]
     fn malformed_match_arm_tuple_enum_missing_pattern() {
         // We are testing to be sure we don't panic here when the match
         // arm `Either::B` is missing its pattern.
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index bf2da2d4a..0ee851a74 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -137,8 +137,12 @@ pub struct InferenceResult {
     assoc_resolutions: FxHashMap<ExprOrPatId, AssocItemId>,
     diagnostics: Vec<InferenceDiagnostic>,
     pub type_of_expr: ArenaMap<ExprId, Ty>,
+    /// For each pattern record the type it resolves to.
+    ///
+    /// **Note**: When a pattern type is resolved it may still contain
+    /// unresolved or missing subpatterns or subpatterns of mismatched types.
     pub type_of_pat: ArenaMap<PatId, Ty>,
-    pub(super) type_mismatches: ArenaMap<ExprId, TypeMismatch>,
+    type_mismatches: FxHashMap<ExprOrPatId, TypeMismatch>,
     /// Interned Unknown to return references to.
     standard_types: InternedStandardTypes,
 }
@@ -163,7 +167,22 @@ impl InferenceResult {
         self.assoc_resolutions.get(&id.into()).copied()
     }
     pub fn type_mismatch_for_expr(&self, expr: ExprId) -> Option<&TypeMismatch> {
-        self.type_mismatches.get(expr)
+        self.type_mismatches.get(&expr.into())
+    }
+    pub fn type_mismatch_for_pat(&self, pat: PatId) -> Option<&TypeMismatch> {
+        self.type_mismatches.get(&pat.into())
+    }
+    pub fn expr_type_mismatches(&self) -> impl Iterator<Item = (ExprId, &TypeMismatch)> {
+        self.type_mismatches.iter().filter_map(|(expr_or_pat, mismatch)| match *expr_or_pat {
+            ExprOrPatId::ExprId(expr) => Some((expr, mismatch)),
+            _ => None,
+        })
+    }
+    pub fn pat_type_mismatches(&self) -> impl Iterator<Item = (PatId, &TypeMismatch)> {
+        self.type_mismatches.iter().filter_map(|(expr_or_pat, mismatch)| match *expr_or_pat {
+            ExprOrPatId::PatId(pat) => Some((pat, mismatch)),
+            _ => None,
+        })
     }
     pub fn add_diagnostics(
         &self,
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index b6b5a1b75..7278faeec 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -42,7 +42,7 @@ impl<'a> InferenceContext<'a> {
         let could_unify = self.unify(&ty, &expected.ty);
         if !could_unify {
             self.result.type_mismatches.insert(
-                tgt_expr,
+                tgt_expr.into(),
                 TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() },
             );
         }
@@ -54,9 +54,10 @@ impl<'a> InferenceContext<'a> {
     pub(super) fn infer_expr_coerce(&mut self, expr: ExprId, expected: &Expectation) -> Ty {
         let ty = self.infer_expr_inner(expr, &expected);
         let ty = if !self.coerce(&ty, &expected.coercion_target()) {
-            self.result
-                .type_mismatches
-                .insert(expr, TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() });
+            self.result.type_mismatches.insert(
+                expr.into(),
+                TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() },
+            );
             // Return actual type when type mismatch.
             // This is needed for diagnostic when return type mismatch.
             ty
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 60b94a642..b15f4977d 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -10,7 +10,7 @@ use hir_def::{
 };
 use hir_expand::name::Name;
 
-use super::{BindingMode, Expectation, InferenceContext};
+use super::{BindingMode, Expectation, InferenceContext, TypeMismatch};
 use crate::{
     lower::lower_to_chalk_mutability, static_lifetime, Interner, Substitution, Ty, TyBuilder,
     TyExt, TyKind,
@@ -266,7 +266,10 @@ impl<'a> InferenceContext<'a> {
         // use a new type variable if we got error type here
         let ty = self.insert_type_vars_shallow(ty);
         if !self.unify(&ty, expected) {
-            // FIXME record mismatch, we need to change the type of self.type_mismatches for that
+            self.result.type_mismatches.insert(
+                pat.into(),
+                TypeMismatch { expected: expected.clone(), actual: ty.clone() },
+            );
         }
         let ty = self.resolve_ty_as_possible(ty);
         self.write_pat_ty(pat, ty.clone());
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index ccfb88c52..cc819373c 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -130,7 +130,10 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
                 }
                 Err(SyntheticSyntax) => continue,
             };
-            types.push((syntax_ptr, ty));
+            types.push((syntax_ptr.clone(), ty));
+            if let Some(mismatch) = inference_result.type_mismatch_for_pat(pat) {
+                mismatches.push((syntax_ptr, mismatch));
+            }
         }
 
         for (expr, ty) in inference_result.type_of_expr.iter() {
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index 787647e9f..ddbadbe40 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -546,7 +546,9 @@ fn infer_const_pattern() {
             273..276 'Bar': usize
             280..283 'Bar': usize
             200..223: expected (), got Foo
+            211..214: expected (), got Foo
             262..285: expected (), got usize
+            273..276: expected (), got usize
         "#]],
     );
 }
@@ -703,7 +705,7 @@ fn box_pattern() {
 
 #[test]
 fn tuple_ellipsis_pattern() {
-    check_infer(
+    check_infer_with_mismatches(
         r#"
 fn foo(tuple: (u8, i16, f32)) {
     match tuple {
@@ -744,6 +746,8 @@ fn foo(tuple: (u8, i16, f32)) {
             186..200 '{/*too long*/}': ()
             209..210 '_': (u8, i16, f32)
             214..216 '{}': ()
+            136..142: expected (u8, i16, f32), got (u8, i16)
+            170..182: expected (u8, i16, f32), got (u8, i16, f32, _)
         "#]],
     );
 }
@@ -851,3 +855,55 @@ fn f(e: Enum) {
     "#,
     )
 }
+
+#[test]
+fn type_mismatch_in_or_pattern() {
+    check_infer_with_mismatches(
+        r#"
+fn main() {
+    match (false,) {
+        (true | (),) => {}
+        (() | true,) => {}
+        (_ | (),) => {}
+        (() | _,) => {}
+    }
+}
+"#,
+        expect![[r#"
+            10..142 '{     ...   } }': ()
+            16..140 'match ...     }': ()
+            22..30 '(false,)': (bool,)
+            23..28 'false': bool
+            41..53 '(true | (),)': (bool,)
+            42..46 'true': bool
+            42..46 'true': bool
+            42..51 'true | ()': bool
+            49..51 '()': ()
+            57..59 '{}': ()
+            68..80 '(() | true,)': ((),)
+            69..71 '()': ()
+            69..78 '() | true': ()
+            74..78 'true': bool
+            74..78 'true': bool
+            84..86 '{}': ()
+            95..104 '(_ | (),)': (bool,)
+            96..97 '_': bool
+            96..102 '_ | ()': bool
+            100..102 '()': ()
+            108..110 '{}': ()
+            119..128 '(() | _,)': ((),)
+            120..122 '()': ()
+            120..126 '() | _': ()
+            125..126 '_': bool
+            132..134 '{}': ()
+            49..51: expected bool, got ()
+            68..80: expected (bool,), got ((),)
+            69..71: expected bool, got ()
+            69..78: expected bool, got ()
+            100..102: expected bool, got ()
+            119..128: expected (bool,), got ((),)
+            120..122: expected bool, got ()
+            120..126: expected bool, got ()
+        "#]],
+    );
+}
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 2bf953305..01fe3a1a1 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -55,12 +55,14 @@ pub(crate) fn prepare_rename(
     match def {
         Definition::SelfType(_) => bail!("Cannot rename `Self`"),
         Definition::ModuleDef(ModuleDef::BuiltinType(_)) => bail!("Cannot rename builtin type"),
-        _ => {}
+        Definition::ModuleDef(ModuleDef::Module(_)) => (),
+        _ => {
+            let nav = def
+                .try_to_nav(sema.db)
+                .ok_or_else(|| format_err!("No references found at position"))?;
+            nav.focus_range.ok_or_else(|| format_err!("No identifier available to rename"))?;
+        }
     };
-    let nav =
-        def.try_to_nav(sema.db).ok_or_else(|| format_err!("No references found at position"))?;
-    nav.focus_range.ok_or_else(|| format_err!("No identifier available to rename"))?;
-
     let name_like = sema
         .find_node_at_offset_with_descend(&syntax, position.offset)
         .ok_or_else(|| format_err!("No references found at position"))?;
diff --git a/crates/ide_assists/src/handlers/add_explicit_type.rs b/crates/ide_assists/src/handlers/add_explicit_type.rs
index 36589203d..b7617ca3d 100644
--- a/crates/ide_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ide_assists/src/handlers/add_explicit_type.rs
@@ -1,6 +1,6 @@
 use hir::HirDisplay;
 use syntax::{
-    ast::{self, AstNode, LetStmt, NameOwner},
+    ast::{self, AstNode, LetStmt},
     TextRange,
 };
 
@@ -31,9 +31,6 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
         _ => return None,
     };
     let pat_range = pat.syntax().text_range();
-    // The binding must have a name
-    let name = pat.name()?;
-    let name_range = name.syntax().text_range();
 
     // Assist should only be applicable if cursor is between 'let' and '='
     let cursor_in_range = {
@@ -74,7 +71,7 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
                 builder.replace(ascribed_ty.syntax().text_range(), inferred_type);
             }
             None => {
-                builder.insert(name_range.end(), format!(": {}", inferred_type));
+                builder.insert(pat_range.end(), format!(": {}", inferred_type));
             }
         },
     )
@@ -246,4 +243,22 @@ fn main() {
 "#,
         );
     }
+
+    #[test]
+    fn type_should_be_added_after_pattern() {
+        // LetStmt = Attr* 'let' Pat (':' Type)? '=' initializer:Expr ';'
+        check_assist(
+            add_explicit_type,
+            r#"
+fn main() {
+    let $0test @ () = ();
+}
+"#,
+            r#"
+fn main() {
+    let test @ (): () = ();
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide_db/src/apply_change.rs b/crates/ide_db/src/apply_change.rs
index eac5ef6b9..f988572ae 100644
--- a/crates/ide_db/src/apply_change.rs
+++ b/crates/ide_db/src/apply_change.rs
@@ -222,7 +222,6 @@ impl RootDatabase {
         sweep_each_query![
             // AstDatabase
             hir::db::InternMacroQuery
-            hir::db::InternEagerExpansionQuery
 
             // InternDatabase
             hir::db::InternFunctionQuery
diff --git a/crates/ide_db/src/symbol_index.rs b/crates/ide_db/src/symbol_index.rs
index da427d686..0f5c4abc4 100644
--- a/crates/ide_db/src/symbol_index.rs
+++ b/crates/ide_db/src/symbol_index.rs
@@ -161,6 +161,11 @@ impl<DB: ParallelDatabase> Clone for Snap<salsa::Snapshot<DB>> {
 // That is, `#` switches from "types" to all symbols, `*` switches from the current
 // workspace to dependencies.
 //
+// Note that filtering does not currently work in VSCode due to the editor never
+// sending the special symbols to the language server. Instead, you can configure
+// the filtering via the `rust-analyzer.workspace.symbol.search.scope` and
+// `rust-analyzer.workspace.symbol.search.kind` settings.
+//
 // |===
 // | Editor  | Shortcut
 //
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index 3c87782f2..b2317618a 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -122,6 +122,7 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
             "runnables": {
                 "kinds": [ "cargo" ],
             },
+            "workspaceSymbolScopeKindFiltering": true,
         })),
     }
 }
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 867d72ea4..b700d025f 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -23,7 +23,8 @@ use vfs::AbsPathBuf;
 
 use crate::{
     caps::completion_item_edit_resolve, diagnostics::DiagnosticsMapConfig,
-    line_index::OffsetEncoding, lsp_ext::supports_utf8,
+    line_index::OffsetEncoding, lsp_ext::supports_utf8, lsp_ext::WorkspaceSymbolSearchKind,
+    lsp_ext::WorkspaceSymbolSearchScope,
 };
 
 // Defines the server-side configuration of the rust-analyzer. We generate
@@ -217,6 +218,11 @@ config_data! {
         /// Advanced option, fully override the command rust-analyzer uses for
         /// formatting.
         rustfmt_overrideCommand: Option<Vec<String>> = "null",
+
+        /// Workspace symbol search scope.
+        workspace_symbol_search_scope: WorskpaceSymbolSearchScopeDef = "\"workspace\"",
+        /// Workspace symbol search kind.
+        workspace_symbol_search_kind: WorskpaceSymbolSearchKindDef = "\"only_types\"",
     }
 }
 
@@ -311,6 +317,15 @@ pub struct RunnablesConfig {
     pub cargo_extra_args: Vec<String>,
 }
 
+/// Configuration for workspace symbol search requests.
+#[derive(Debug, Clone)]
+pub struct WorkspaceSymbolConfig {
+    /// In what scope should the symbol be searched in.
+    pub search_scope: WorkspaceSymbolSearchScope,
+    /// What kind of symbol is being search for.
+    pub search_kind: WorkspaceSymbolSearchKind,
+}
+
 impl Config {
     pub fn new(root_path: AbsPathBuf, caps: ClientCapabilities) -> Self {
         Config { caps, data: ConfigData::default(), discovered_projects: None, root_path }
@@ -691,6 +706,22 @@ impl Config {
             .contains(&MarkupKind::Markdown),
         }
     }
+
+    pub fn workspace_symbol(&self) -> WorkspaceSymbolConfig {
+        WorkspaceSymbolConfig {
+            search_scope: match self.data.workspace_symbol_search_scope {
+                WorskpaceSymbolSearchScopeDef::Workspace => WorkspaceSymbolSearchScope::Workspace,
+                WorskpaceSymbolSearchScopeDef::WorkspaceAndDependencies => {
+                    WorkspaceSymbolSearchScope::WorkspaceAndDependencies
+                }
+            },
+            search_kind: match self.data.workspace_symbol_search_kind {
+                WorskpaceSymbolSearchKindDef::OnlyTypes => WorkspaceSymbolSearchKind::OnlyTypes,
+                WorskpaceSymbolSearchKindDef::AllSymbols => WorkspaceSymbolSearchKind::AllSymbols,
+            },
+        }
+    }
+
     pub fn semantic_tokens_refresh(&self) -> bool {
         try_or!(self.caps.workspace.as_ref()?.semantic_tokens.as_ref()?.refresh_support?, false)
     }
@@ -739,6 +770,20 @@ enum ImportPrefixDef {
     ByCrate,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+enum WorskpaceSymbolSearchScopeDef {
+    Workspace,
+    WorkspaceAndDependencies,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+enum WorskpaceSymbolSearchKindDef {
+    OnlyTypes,
+    AllSymbols,
+}
+
 macro_rules! _config_data {
     (struct $name:ident {
         $(
@@ -919,6 +964,22 @@ fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json
             "type": "array",
             "items": { "type": ["string", "object"] },
         },
+        "WorskpaceSymbolSearchScopeDef" => set! {
+            "type": "string",
+            "enum": ["workspace", "workspace_and_dependencies"],
+            "enumDescriptions": [
+                "Search in current workspace only",
+                "Search in current workspace and dependencies"
+            ],
+        },
+        "WorskpaceSymbolSearchKindDef" => set! {
+            "type": "string",
+            "enum": ["only_types", "all_symbols"],
+            "enumDescriptions": [
+                "Search for types only",
+                "Search for all symbols kinds"
+            ],
+        },
         _ => panic!("{}: {}", ty, default),
     }
 
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 8fe97fd7c..51041d7a0 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -38,7 +38,7 @@ use crate::{
     from_proto,
     global_state::{GlobalState, GlobalStateSnapshot},
     line_index::LineEndings,
-    lsp_ext::{self, InlayHint, InlayHintsParams},
+    lsp_ext::{self, InlayHint, InlayHintsParams, WorkspaceSymbolParams},
     lsp_utils::all_edits_are_disjoint,
     to_proto, LspError, Result,
 };
@@ -380,11 +380,12 @@ pub(crate) fn handle_document_symbol(
 
 pub(crate) fn handle_workspace_symbol(
     snap: GlobalStateSnapshot,
-    params: lsp_types::WorkspaceSymbolParams,
+    params: WorkspaceSymbolParams,
 ) -> Result<Option<Vec<SymbolInformation>>> {
     let _p = profile::span("handle_workspace_symbol");
-    let all_symbols = params.query.contains('#');
-    let libs = params.query.contains('*');
+
+    let (all_symbols, libs) = decide_search_scope_and_kind(&params, &snap);
+
     let query = {
         let query: String = params.query.chars().filter(|&c| c != '#' && c != '*').collect();
         let mut q = Query::new(query);
@@ -406,6 +407,45 @@ pub(crate) fn handle_workspace_symbol(
 
     return Ok(Some(res));
 
+    fn decide_search_scope_and_kind(
+        params: &WorkspaceSymbolParams,
+        snap: &GlobalStateSnapshot,
+    ) -> (bool, bool) {
+        // Support old-style parsing of markers in the query.
+        let mut all_symbols = params.query.contains('#');
+        let mut libs = params.query.contains('*');
+
+        let config = snap.config.workspace_symbol();
+
+        // If no explicit marker was set, check request params. If that's also empty
+        // use global config.
+        if !all_symbols {
+            let search_kind = if let Some(ref search_kind) = params.search_kind {
+                search_kind
+            } else {
+                &config.search_kind
+            };
+            all_symbols = match search_kind {
+                lsp_ext::WorkspaceSymbolSearchKind::OnlyTypes => false,
+                lsp_ext::WorkspaceSymbolSearchKind::AllSymbols => true,
+            }
+        }
+
+        if !libs {
+            let search_scope = if let Some(ref search_scope) = params.search_scope {
+                search_scope
+            } else {
+                &config.search_scope
+            };
+            libs = match search_scope {
+                lsp_ext::WorkspaceSymbolSearchScope::Workspace => false,
+                lsp_ext::WorkspaceSymbolSearchScope::WorkspaceAndDependencies => true,
+            }
+        }
+
+        (all_symbols, libs)
+    }
+
     fn exec_query(snap: &GlobalStateSnapshot, query: Query) -> Result<Vec<SymbolInformation>> {
         let mut res = Vec::new();
         for nav in snap.analysis.symbol_search(query)? {
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 3bd098058..34b53a7a8 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -4,7 +4,8 @@ use std::{collections::HashMap, path::PathBuf};
 
 use lsp_types::request::Request;
 use lsp_types::{
-    notification::Notification, CodeActionKind, Position, Range, TextDocumentIdentifier,
+    notification::Notification, CodeActionKind, PartialResultParams, Position, Range,
+    TextDocumentIdentifier, WorkDoneProgressParams,
 };
 use serde::{Deserialize, Serialize};
 
@@ -438,3 +439,42 @@ pub enum MoveItemDirection {
     Up,
     Down,
 }
+
+#[derive(Debug)]
+pub enum WorkspaceSymbol {}
+
+impl Request for WorkspaceSymbol {
+    type Params = WorkspaceSymbolParams;
+    type Result = Option<Vec<lsp_types::SymbolInformation>>;
+    const METHOD: &'static str = "workspace/symbol";
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
+pub struct WorkspaceSymbolParams {
+    #[serde(flatten)]
+    pub partial_result_params: PartialResultParams,
+
+    #[serde(flatten)]
+    pub work_done_progress_params: WorkDoneProgressParams,
+
+    /// A non-empty query string
+    pub query: String,
+
+    pub search_scope: Option<WorkspaceSymbolSearchScope>,
+
+    pub search_kind: Option<WorkspaceSymbolSearchKind>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum WorkspaceSymbolSearchScope {
+    Workspace,
+    WorkspaceAndDependencies,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum WorkspaceSymbolSearchKind {
+    OnlyTypes,
+    AllSymbols,
+}
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index c7bd7eee1..4e0791611 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -525,9 +525,9 @@ impl GlobalState {
             .on::<lsp_ext::ExternalDocs>(handlers::handle_open_docs)
             .on::<lsp_ext::OpenCargoToml>(handlers::handle_open_cargo_toml)
             .on::<lsp_ext::MoveItem>(handlers::handle_move_item)
+            .on::<lsp_ext::WorkspaceSymbol>(handlers::handle_workspace_symbol)
             .on::<lsp_types::request::OnTypeFormatting>(handlers::handle_on_type_formatting)
             .on::<lsp_types::request::DocumentSymbolRequest>(handlers::handle_document_symbol)
-            .on::<lsp_types::request::WorkspaceSymbol>(handlers::handle_workspace_symbol)
             .on::<lsp_types::request::GotoDefinition>(handlers::handle_goto_definition)
             .on::<lsp_types::request::GotoImplementation>(handlers::handle_goto_implementation)
             .on::<lsp_types::request::GotoTypeDefinition>(handlers::handle_goto_type_definition)