22 files changed, 391 insertions, 272 deletions

diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 8eef51828..2bc34d449 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -117,7 +117,14 @@ fn lower_enum(
     ast: &InFile<ast::EnumDef>,
     module_id: ModuleId,
 ) {
-    for var in ast.value.variant_list().into_iter().flat_map(|it| it.variants()) {
+    let expander = CfgExpander::new(db, ast.file_id, module_id.krate);
+    let variants = ast
+        .value
+        .variant_list()
+        .into_iter()
+        .flat_map(|it| it.variants())
+        .filter(|var| expander.is_cfg_enabled(var));
+    for var in variants {
         trace.alloc(
             || var.clone(),
             || EnumVariantData {
@@ -209,8 +216,7 @@ fn lower_struct(
     match &ast.value {
         ast::StructKind::Tuple(fl) => {
             for (i, fd) in fl.fields().enumerate() {
-                let attrs = expander.parse_attrs(&fd);
-                if !expander.is_cfg_enabled(&attrs) {
+                if !expander.is_cfg_enabled(&fd) {
                     continue;
                 }
 
@@ -227,8 +233,7 @@ fn lower_struct(
         }
         ast::StructKind::Record(fl) => {
             for fd in fl.fields() {
-                let attrs = expander.parse_attrs(&fd);
-                if !expander.is_cfg_enabled(&attrs) {
+                if !expander.is_cfg_enabled(&fd) {
                     continue;
                 }
 
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 5a86af8ba..576cd0c65 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -140,6 +140,7 @@ impl Attr {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
 pub struct AttrQuery<'a> {
     attrs: &'a Attrs,
     key: &'static str,
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 4edaad960..f5a7305dc 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -60,7 +60,8 @@ impl CfgExpander {
         Attrs::new(owner, &self.hygiene)
     }
 
-    pub(crate) fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
+    pub(crate) fn is_cfg_enabled(&self, owner: &dyn ast::AttrsOwner) -> bool {
+        let attrs = self.parse_attrs(owner);
         attrs.is_cfg_enabled(&self.cfg_options)
     }
 }
@@ -141,12 +142,8 @@ impl Expander {
         InFile { file_id: self.current_file_id, value }
     }
 
-    pub(crate) fn parse_attrs(&self, owner: &dyn ast::AttrsOwner) -> Attrs {
-        self.cfg_expander.parse_attrs(owner)
-    }
-
-    pub(crate) fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
-        self.cfg_expander.is_cfg_enabled(attrs)
+    pub(crate) fn is_cfg_enabled(&self, owner: &dyn ast::AttrsOwner) -> bool {
+        self.cfg_expander.is_cfg_enabled(owner)
     }
 
     fn parse_path(&mut self, path: ast::Path) -> Option<Path> {
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index e9dd65b0a..e08d62dd6 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -15,7 +15,7 @@ use ra_syntax::{
     },
     AstNode, AstPtr,
 };
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     adt::StructKind,
@@ -60,13 +60,10 @@ pub(super) fn lower(
     params: Option<ast::ParamList>,
     body: Option<ast::Expr>,
 ) -> (Body, BodySourceMap) {
-    let ctx = LowerCtx::new(db, expander.current_file_id.clone());
-
     ExprCollector {
         db,
         def,
         expander,
-        ctx,
         source_map: BodySourceMap::default(),
         body: Body {
             exprs: Arena::default(),
@@ -83,7 +80,6 @@ struct ExprCollector<'a> {
     db: &'a dyn DefDatabase,
     def: DefWithBodyId,
     expander: Expander,
-    ctx: LowerCtx,
     body: Body,
     source_map: BodySourceMap,
 }
@@ -122,6 +118,10 @@ impl ExprCollector<'_> {
         (self.body, self.source_map)
     }
 
+    fn ctx(&self) -> LowerCtx {
+        LowerCtx::new(self.db, self.expander.current_file_id)
+    }
+
     fn alloc_expr(&mut self, expr: Expr, ptr: AstPtr<ast::Expr>) -> ExprId {
         let src = self.expander.to_source(ptr);
         let id = self.make_expr(expr, Ok(src.clone()));
@@ -162,8 +162,7 @@ impl ExprCollector<'_> {
 
     fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
         let syntax_ptr = AstPtr::new(&expr);
-        let attrs = self.expander.parse_attrs(&expr);
-        if !self.expander.is_cfg_enabled(&attrs) {
+        if !self.expander.is_cfg_enabled(&expr) {
             return self.missing_expr();
         }
         match expr {
@@ -203,6 +202,16 @@ impl ExprCollector<'_> {
 
                 self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
             }
+            ast::Expr::EffectExpr(e) => match e.effect() {
+                ast::Effect::Try(_) => {
+                    let body = self.collect_block_opt(e.block_expr());
+                    self.alloc_expr(Expr::TryBlock { body }, syntax_ptr)
+                }
+                // FIXME: we need to record these effects somewhere...
+                ast::Effect::Async(_) | ast::Effect::Label(_) | ast::Effect::Unsafe(_) => {
+                    self.collect_block_opt(e.block_expr())
+                }
+            },
             ast::Expr::BlockExpr(e) => self.collect_block(e),
             ast::Expr::LoopExpr(e) => {
                 let body = self.collect_block_opt(e.loop_body());
@@ -217,7 +226,7 @@ impl ExprCollector<'_> {
                         None => self.collect_expr_opt(condition.expr()),
                         // if let -- desugar to match
                         Some(pat) => {
-                            tested_by!(infer_resolve_while_let);
+                            mark::hit!(infer_resolve_while_let);
                             let pat = self.collect_pat(pat);
                             let match_expr = self.collect_expr_opt(condition.expr());
                             let placeholder_pat = self.missing_pat();
@@ -259,7 +268,7 @@ impl ExprCollector<'_> {
                 };
                 let method_name = e.name_ref().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
                 let generic_args =
-                    e.type_arg_list().and_then(|it| GenericArgs::from_ast(&self.ctx, it));
+                    e.type_arg_list().and_then(|it| GenericArgs::from_ast(&self.ctx(), it));
                 self.alloc_expr(
                     Expr::MethodCall { receiver, method_name, args, generic_args },
                     syntax_ptr,
@@ -319,8 +328,7 @@ impl ExprCollector<'_> {
                         .fields()
                         .inspect(|field| field_ptrs.push(AstPtr::new(field)))
                         .filter_map(|field| {
-                            let attrs = self.expander.parse_attrs(&field);
-                            if !self.expander.is_cfg_enabled(&attrs) {
+                            if !self.expander.is_cfg_enabled(&field) {
                                 return None;
                             }
                             let name = field.field_name()?.as_name();
@@ -365,7 +373,7 @@ impl ExprCollector<'_> {
             }
             ast::Expr::CastExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
-                let type_ref = TypeRef::from_ast_opt(&self.ctx, e.type_ref());
+                let type_ref = TypeRef::from_ast_opt(&self.ctx(), e.type_ref());
                 self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
             }
             ast::Expr::RefExpr(e) => {
@@ -388,7 +396,7 @@ impl ExprCollector<'_> {
                     for param in pl.params() {
                         let pat = self.collect_pat_opt(param.pat());
                         let type_ref =
-                            param.ascribed_type().map(|it| TypeRef::from_ast(&self.ctx, it));
+                            param.ascribed_type().map(|it| TypeRef::from_ast(&self.ctx(), it));
                         args.push(pat);
                         arg_types.push(type_ref);
                     }
@@ -396,7 +404,7 @@ impl ExprCollector<'_> {
                 let ret_type = e
                     .ret_type()
                     .and_then(|r| r.type_ref())
-                    .map(|it| TypeRef::from_ast(&self.ctx, it));
+                    .map(|it| TypeRef::from_ast(&self.ctx(), it));
                 let body = self.collect_expr_opt(e.body());
                 self.alloc_expr(Expr::Lambda { args, arg_types, ret_type, body }, syntax_ptr)
             }
@@ -456,6 +464,7 @@ impl ExprCollector<'_> {
                         krate: Some(self.expander.module.krate),
                         ast_id: Some(self.expander.ast_id(&e)),
                         kind: MacroDefKind::Declarative,
+                        local_inner: false,
                     };
                     self.body.item_scope.define_legacy_macro(name, mac);
 
@@ -490,19 +499,16 @@ impl ExprCollector<'_> {
         }
     }
 
-    fn collect_block(&mut self, expr: ast::BlockExpr) -> ExprId {
-        let syntax_node_ptr = AstPtr::new(&expr.clone().into());
-        let block = match expr.block() {
-            Some(block) => block,
-            None => return self.alloc_expr(Expr::Missing, syntax_node_ptr),
-        };
+    fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
+        let syntax_node_ptr = AstPtr::new(&block.clone().into());
         self.collect_block_items(&block);
         let statements = block
             .statements()
             .map(|s| match s {
                 ast::Stmt::LetStmt(stmt) => {
                     let pat = self.collect_pat_opt(stmt.pat());
-                    let type_ref = stmt.ascribed_type().map(|it| TypeRef::from_ast(&self.ctx, it));
+                    let type_ref =
+                        stmt.ascribed_type().map(|it| TypeRef::from_ast(&self.ctx(), it));
                     let initializer = stmt.initializer().map(|e| self.collect_expr(e));
                     Statement::Let { pat, type_ref, initializer }
                 }
@@ -513,7 +519,7 @@ impl ExprCollector<'_> {
         self.alloc_expr(Expr::Block { statements, tail }, syntax_node_ptr)
     }
 
-    fn collect_block_items(&mut self, block: &ast::Block) {
+    fn collect_block_items(&mut self, block: &ast::BlockExpr) {
         let container = ContainerId::DefWithBodyId(self.def);
         for item in block.items() {
             let (def, name): (ModuleDefId, Option<ast::Name>) = match item {
@@ -568,9 +574,16 @@ impl ExprCollector<'_> {
             self.body.item_scope.define_def(def);
             if let Some(name) = name {
                 let vis = crate::visibility::Visibility::Public; // FIXME determine correctly
-                self.body
-                    .item_scope
-                    .push_res(name.as_name(), crate::per_ns::PerNs::from_def(def, vis));
+                let has_constructor = match def {
+                    ModuleDefId::AdtId(AdtId::StructId(s)) => {
+                        self.db.struct_data(s).variant_data.kind() != StructKind::Record
+                    }
+                    _ => true,
+                };
+                self.body.item_scope.push_res(
+                    name.as_name(),
+                    crate::per_ns::PerNs::from_def(def, vis, has_constructor),
+                );
             }
         }
     }
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs
index 86f953c80..09e92b74e 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -174,7 +174,7 @@ mod tests {
     use hir_expand::{name::AsName, InFile};
     use ra_db::{fixture::WithFixture, FileId, SourceDatabase};
     use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
-    use test_utils::{assert_eq_text, covers, extract_offset};
+    use test_utils::{assert_eq_text, extract_offset, mark};
 
     use crate::{db::DefDatabase, test_db::TestDB, FunctionId, ModuleDefId};
 
@@ -388,7 +388,7 @@ mod tests {
 
     #[test]
     fn while_let_desugaring() {
-        covers!(infer_resolve_while_let);
+        mark::check!(infer_resolve_while_let);
         do_check_local_name(
             r#"
 fn test() {
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 7a2067e49..e2130d931 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -9,7 +9,7 @@ use hir_expand::{
 };
 use ra_prof::profile;
 use ra_syntax::ast::{
-    self, AstNode, ImplItem, ModuleItemOwner, NameOwner, TypeAscriptionOwner, TypeBoundsOwner,
+    self, AssocItem, AstNode, ModuleItemOwner, NameOwner, TypeAscriptionOwner, TypeBoundsOwner,
     VisibilityOwner,
 };
 
@@ -150,51 +150,31 @@ pub struct TraitData {
 
 impl TraitData {
     pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
-        let src = tr.lookup(db).source(db);
+        let tr_loc = tr.lookup(db);
+        let src = tr_loc.source(db);
         let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
         let auto = src.value.auto_token().is_some();
-        let ast_id_map = db.ast_id_map(src.file_id);
+        let module_id = tr_loc.container.module(db);
 
         let container = AssocContainerId::TraitId(tr);
-        let items = if let Some(item_list) = src.value.item_list() {
-            item_list
-                .impl_items()
-                .map(|item_node| match item_node {
-                    ast::ImplItem::FnDef(it) => {
-                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                        let def = FunctionLoc {
-                            container,
-                            ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
-                        }
-                        .intern(db)
-                        .into();
-                        (name, def)
-                    }
-                    ast::ImplItem::ConstDef(it) => {
-                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                        let def = ConstLoc {
-                            container,
-                            ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
-                        }
-                        .intern(db)
-                        .into();
-                        (name, def)
-                    }
-                    ast::ImplItem::TypeAliasDef(it) => {
-                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                        let def = TypeAliasLoc {
-                            container,
-                            ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
-                        }
-                        .intern(db)
-                        .into();
-                        (name, def)
-                    }
-                })
-                .collect()
-        } else {
-            Vec::new()
-        };
+        let mut items = Vec::new();
+
+        if let Some(item_list) = src.value.item_list() {
+            let mut expander = Expander::new(db, tr_loc.ast_id.file_id, module_id);
+            items.extend(collect_items(
+                db,
+                &mut expander,
+                item_list.assoc_items(),
+                src.file_id,
+                container,
+            ));
+            items.extend(collect_items_in_macros(
+                db,
+                &mut expander,
+                &src.with_value(item_list),
+                container,
+            ));
+        }
         Arc::new(TraitData { name, items, auto })
     }
 
@@ -232,24 +212,22 @@ impl ImplData {
         let target_type = TypeRef::from_ast_opt(&lower_ctx, src.value.target_type());
         let is_negative = src.value.excl_token().is_some();
         let module_id = impl_loc.container.module(db);
+        let container = AssocContainerId::ImplId(id);
 
-        let mut items = Vec::new();
+        let mut items: Vec<AssocItemId> = Vec::new();
 
         if let Some(item_list) = src.value.item_list() {
             let mut expander = Expander::new(db, impl_loc.ast_id.file_id, module_id);
-            items.extend(collect_impl_items(
-                db,
-                &mut expander,
-                item_list.impl_items(),
-                src.file_id,
-                id,
-            ));
-            items.extend(collect_impl_items_in_macros(
-                db,
-                &mut expander,
-                &src.with_value(item_list),
-                id,
-            ));
+            items.extend(
+                collect_items(db, &mut expander, item_list.assoc_items(), src.file_id, container)
+                    .into_iter()
+                    .map(|(_, item)| item),
+            );
+            items.extend(
+                collect_items_in_macros(db, &mut expander, &src.with_value(item_list), container)
+                    .into_iter()
+                    .map(|(_, item)| item),
+            );
         }
 
         let res = ImplData { target_trait, target_type, items, is_negative };
@@ -273,11 +251,6 @@ impl ConstData {
         Arc::new(ConstData::new(db, vis_default, node))
     }
 
-    pub(crate) fn static_data_query(db: &dyn DefDatabase, konst: StaticId) -> Arc<ConstData> {
-        let node = konst.lookup(db).source(db);
-        Arc::new(ConstData::new(db, RawVisibility::private(), node))
-    }
-
     fn new<N: NameOwner + TypeAscriptionOwner + VisibilityOwner>(
         db: &dyn DefDatabase,
         vis_default: RawVisibility,
@@ -292,49 +265,76 @@ impl ConstData {
     }
 }
 
-fn collect_impl_items_in_macros(
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct StaticData {
+    pub name: Option<Name>,
+    pub type_ref: TypeRef,
+    pub visibility: RawVisibility,
+    pub mutable: bool,
+}
+
+impl StaticData {
+    pub(crate) fn static_data_query(db: &dyn DefDatabase, konst: StaticId) -> Arc<StaticData> {
+        let node = konst.lookup(db).source(db);
+        let ctx = LowerCtx::new(db, node.file_id);
+
+        let name = node.value.name().map(|n| n.as_name());
+        let type_ref = TypeRef::from_ast_opt(&ctx, node.value.ascribed_type());
+        let mutable = node.value.mut_token().is_some();
+        let visibility = RawVisibility::from_ast_with_default(
+            db,
+            RawVisibility::private(),
+            node.map(|n| n.visibility()),
+        );
+
+        Arc::new(StaticData { name, type_ref, visibility, mutable })
+    }
+}
+
+fn collect_items_in_macros(
     db: &dyn DefDatabase,
     expander: &mut Expander,
     impl_def: &InFile<ast::ItemList>,
-    id: ImplId,
-) -> Vec<AssocItemId> {
+    container: AssocContainerId,
+) -> Vec<(Name, AssocItemId)> {
     let mut res = Vec::new();
 
     // We set a limit to protect against infinite recursion
     let limit = 100;
 
     for m in impl_def.value.syntax().children().filter_map(ast::MacroCall::cast) {
-        res.extend(collect_impl_items_in_macro(db, expander, m, id, limit))
+        res.extend(collect_items_in_macro(db, expander, m, container, limit))
     }
 
     res
 }
 
-fn collect_impl_items_in_macro(
+fn collect_items_in_macro(
     db: &dyn DefDatabase,
     expander: &mut Expander,
     m: ast::MacroCall,
-    id: ImplId,
+    container: AssocContainerId,
     limit: usize,
-) -> Vec<AssocItemId> {
+) -> Vec<(Name, AssocItemId)> {
     if limit == 0 {
         return Vec::new();
     }
 
     if let Some((mark, items)) = expander.enter_expand(db, None, m) {
         let items: InFile<ast::MacroItems> = expander.to_source(items);
-        let mut res = collect_impl_items(
+        let mut res = collect_items(
             db,
             expander,
-            items.value.items().filter_map(|it| ImplItem::cast(it.syntax().clone())),
+            items.value.items().filter_map(|it| AssocItem::cast(it.syntax().clone())),
             items.file_id,
-            id,
+            container,
         );
+
         // Recursive collect macros
         // Note that ast::ModuleItem do not include ast::MacroCall
         // We cannot use ModuleItemOwner::items here
         for it in items.value.syntax().children().filter_map(ast::MacroCall::cast) {
-            res.extend(collect_impl_items_in_macro(db, expander, it, id, limit - 1))
+            res.extend(collect_items_in_macro(db, expander, it, container, limit - 1))
         }
         expander.exit(db, mark);
         res
@@ -343,44 +343,38 @@ fn collect_impl_items_in_macro(
     }
 }
 
-fn collect_impl_items(
+fn collect_items(
     db: &dyn DefDatabase,
     expander: &mut Expander,
-    impl_items: impl Iterator<Item = ImplItem>,
+    assoc_items: impl Iterator<Item = AssocItem>,
     file_id: crate::HirFileId,
-    id: ImplId,
-) -> Vec<AssocItemId> {
+    container: AssocContainerId,
+) -> Vec<(Name, AssocItemId)> {
     let items = db.ast_id_map(file_id);
 
-    impl_items
+    assoc_items
         .filter_map(|item_node| match item_node {
-            ast::ImplItem::FnDef(it) => {
-                let attrs = expander.parse_attrs(&it);
-                if !expander.is_cfg_enabled(&attrs) {
+            ast::AssocItem::FnDef(it) => {
+                let name = it.name().map_or_else(Name::missing, |it| it.as_name());
+                if !expander.is_cfg_enabled(&it) {
                     return None;
                 }
-                let def = FunctionLoc {
-                    container: AssocContainerId::ImplId(id),
-                    ast_id: AstId::new(file_id, items.ast_id(&it)),
-                }
-                .intern(db);
-                Some(def.into())
+                let def = FunctionLoc { container, ast_id: AstId::new(file_id, items.ast_id(&it)) }
+                    .intern(db);
+                Some((name, def.into()))
             }
-            ast::ImplItem::ConstDef(it) => {
-                let def = ConstLoc {
-                    container: AssocContainerId::ImplId(id),
-                    ast_id: AstId::new(file_id, items.ast_id(&it)),
-                }
-                .intern(db);
-                Some(def.into())
+            ast::AssocItem::ConstDef(it) => {
+                let name = it.name().map_or_else(Name::missing, |it| it.as_name());
+                let def = ConstLoc { container, ast_id: AstId::new(file_id, items.ast_id(&it)) }
+                    .intern(db);
+                Some((name, def.into()))
             }
-            ast::ImplItem::TypeAliasDef(it) => {
-                let def = TypeAliasLoc {
-                    container: AssocContainerId::ImplId(id),
-                    ast_id: AstId::new(file_id, items.ast_id(&it)),
-                }
-                .intern(db);
-                Some(def.into())
+            ast::AssocItem::TypeAliasDef(it) => {
+                let name = it.name().map_or_else(Name::missing, |it| it.as_name());
+                let def =
+                    TypeAliasLoc { container, ast_id: AstId::new(file_id, items.ast_id(&it)) }
+                        .intern(db);
+                Some((name, def.into()))
             }
         })
         .collect()
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index 5dc7395f5..945a0025e 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -1,7 +1,7 @@
 //! Defines database & queries for name resolution.
 use std::sync::Arc;
 
-use hir_expand::{db::AstDatabase, HirFileId};
+use hir_expand::{db::AstDatabase, name::Name, HirFileId};
 use ra_db::{salsa, CrateId, SourceDatabase, Upcast};
 use ra_prof::profile;
 use ra_syntax::SmolStr;
@@ -10,11 +10,15 @@ use crate::{
     adt::{EnumData, StructData},
     attr::Attrs,
     body::{scope::ExprScopes, Body, BodySourceMap},
-    data::{ConstData, FunctionData, ImplData, TraitData, TypeAliasData},
+    data::{ConstData, FunctionData, ImplData, StaticData, TraitData, TypeAliasData},
     docs::Documentation,
+    find_path,
     generics::GenericParams,
+    item_scope::ItemInNs,
     lang_item::{LangItemTarget, LangItems},
     nameres::{raw::RawItems, CrateDefMap},
+    path::ModPath,
+    visibility::Visibility,
     AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
     GenericDefId, ImplId, ImplLoc, ModuleId, StaticId, StaticLoc, StructId, StructLoc, TraitId,
     TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
@@ -77,8 +81,8 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
     #[salsa::invoke(ConstData::const_data_query)]
     fn const_data(&self, konst: ConstId) -> Arc<ConstData>;
 
-    #[salsa::invoke(ConstData::static_data_query)]
-    fn static_data(&self, konst: StaticId) -> Arc<ConstData>;
+    #[salsa::invoke(StaticData::static_data_query)]
+    fn static_data(&self, konst: StaticId) -> Arc<StaticData>;
 
     #[salsa::invoke(Body::body_with_source_map_query)]
     fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);
@@ -108,6 +112,16 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
     // Remove this query completely, in favor of `Attrs::docs` method
     #[salsa::invoke(Documentation::documentation_query)]
     fn documentation(&self, def: AttrDefId) -> Option<Documentation>;
+
+    #[salsa::invoke(find_path::importable_locations_of_query)]
+    fn importable_locations_of(
+        &self,
+        item: ItemInNs,
+        krate: CrateId,
+    ) -> Arc<[(ModuleId, Name, Visibility)]>;
+
+    #[salsa::invoke(find_path::find_path_inner_query)]
+    fn find_path_inner(&self, item: ItemInNs, from: ModuleId, max_len: usize) -> Option<ModPath>;
 }
 
 fn crate_def_map_wait(db: &impl DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs
index aad12e123..a0cdad529 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -101,6 +101,9 @@ pub enum Expr {
     Try {
         expr: ExprId,
     },
+    TryBlock {
+        body: ExprId,
+    },
     Cast {
         expr: ExprId,
         type_ref: TypeRef,
@@ -236,6 +239,7 @@ impl Expr {
                     f(*expr);
                 }
             }
+            Expr::TryBlock { body } => f(*body),
             Expr::Loop { body } => f(*body),
             Expr::While { condition, body } => {
                 f(*condition);
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index 70dcb03e6..4db798473 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -1,5 +1,11 @@
 //! An algorithm to find a path to refer to a certain item.
 
+use std::sync::Arc;
+
+use hir_expand::name::{known, AsName, Name};
+use ra_prof::profile;
+use test_utils::mark;
+
 use crate::{
     db::DefDatabase,
     item_scope::ItemInNs,
@@ -7,25 +13,28 @@ use crate::{
     visibility::Visibility,
     CrateId, ModuleDefId, ModuleId,
 };
-use hir_expand::name::{known, AsName, Name};
-use test_utils::tested_by;
+
+// FIXME: handle local items
+
+/// Find a path that can be used to refer to a certain item. This can depend on
+/// *from where* you're referring to the item, hence the `from` parameter.
+pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
+    let _p = profile("find_path");
+    db.find_path_inner(item, from, MAX_PATH_LEN)
+}
 
 const MAX_PATH_LEN: usize = 15;
 
 impl ModPath {
     fn starts_with_std(&self) -> bool {
-        self.segments.first().filter(|&first_segment| first_segment == &known::std).is_some()
+        self.segments.first() == Some(&known::std)
     }
 
     // When std library is present, paths starting with `std::`
     // should be preferred over paths starting with `core::` and `alloc::`
     fn can_start_with_std(&self) -> bool {
-        self.segments
-            .first()
-            .filter(|&first_segment| {
-                first_segment == &known::alloc || first_segment == &known::core
-            })
-            .is_some()
+        let first_segment = self.segments.first();
+        first_segment == Some(&known::alloc) || first_segment == Some(&known::core)
     }
 
     fn len(&self) -> usize {
@@ -40,15 +49,7 @@ impl ModPath {
     }
 }
 
-// FIXME: handle local items
-
-/// Find a path that can be used to refer to a certain item. This can depend on
-/// *from where* you're referring to the item, hence the `from` parameter.
-pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
-    find_path_inner(db, item, from, MAX_PATH_LEN)
-}
-
-fn find_path_inner(
+pub(crate) fn find_path_inner_query(
     db: &dyn DefDatabase,
     item: ItemInNs,
     from: ModuleId,
@@ -139,8 +140,7 @@ fn find_path_inner(
     let mut best_path = None;
     let mut best_path_len = max_len;
     for (module_id, name) in importable_locations {
-        let mut path = match find_path_inner(
-            db,
+        let mut path = match db.find_path_inner(
             ItemInNs::Types(ModuleDefId::ModuleId(module_id)),
             from,
             best_path_len - 1,
@@ -163,17 +163,19 @@ fn find_path_inner(
 
 fn select_best_path(old_path: ModPath, new_path: ModPath, prefer_no_std: bool) -> ModPath {
     if old_path.starts_with_std() && new_path.can_start_with_std() {
-        tested_by!(prefer_std_paths);
         if prefer_no_std {
+            mark::hit!(prefer_no_std_paths);
             new_path
         } else {
+            mark::hit!(prefer_std_paths);
             old_path
         }
     } else if new_path.starts_with_std() && old_path.can_start_with_std() {
-        tested_by!(prefer_std_paths);
         if prefer_no_std {
+            mark::hit!(prefer_no_std_paths);
             old_path
         } else {
+            mark::hit!(prefer_std_paths);
             new_path
         }
     } else if new_path.len() < old_path.len() {
@@ -198,7 +200,7 @@ fn find_importable_locations(
         .chain(crate_graph[from.krate].dependencies.iter().map(|dep| dep.crate_id))
     {
         result.extend(
-            importable_locations_in_crate(db, item, krate)
+            db.importable_locations_of(item, krate)
                 .iter()
                 .filter(|(_, _, vis)| vis.is_visible_from(db, from))
                 .map(|(m, n, _)| (*m, n.clone())),
@@ -213,11 +215,12 @@ fn find_importable_locations(
 ///
 /// Note that the crate doesn't need to be the one in which the item is defined;
 /// it might be re-exported in other crates.
-fn importable_locations_in_crate(
+pub(crate) fn importable_locations_of_query(
     db: &dyn DefDatabase,
     item: ItemInNs,
     krate: CrateId,
-) -> Vec<(ModuleId, Name, Visibility)> {
+) -> Arc<[(ModuleId, Name, Visibility)]> {
+    let _p = profile("importable_locations_of_query");
     let def_map = db.crate_def_map(krate);
     let mut result = Vec::new();
     for (local_id, data) in def_map.modules.iter() {
@@ -243,17 +246,20 @@ fn importable_locations_in_crate(
             result.push((ModuleId { krate, local_id }, name.clone(), vis));
         }
     }
-    result
+
+    Arc::from(result)
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::test_db::TestDB;
     use hir_expand::hygiene::Hygiene;
     use ra_db::fixture::WithFixture;
     use ra_syntax::ast::AstNode;
-    use test_utils::covers;
+    use test_utils::mark;
+
+    use crate::test_db::TestDB;
+
+    use super::*;
 
     /// `code` needs to contain a cursor marker; checks that `find_path` for the
     /// item the `path` refers to returns that same path when called from the
@@ -508,7 +514,7 @@ mod tests {
 
     #[test]
     fn prefer_std_paths_over_alloc() {
-        covers!(prefer_std_paths);
+        mark::check!(prefer_std_paths);
         let code = r#"
         //- /main.rs crate:main deps:alloc,std
         <|>
@@ -527,51 +533,50 @@ mod tests {
     }
 
     #[test]
-    fn prefer_alloc_paths_over_std() {
-        covers!(prefer_std_paths);
+    fn prefer_core_paths_over_std() {
+        mark::check!(prefer_no_std_paths);
         let code = r#"
-        //- /main.rs crate:main deps:alloc,std
+        //- /main.rs crate:main deps:core,std
         #![no_std]
 
         <|>
 
-        //- /std.rs crate:std deps:alloc
+        //- /std.rs crate:std deps:core
 
-        pub mod sync {
-            pub use alloc::sync::Arc;
+        pub mod fmt {
+            pub use core::fmt::Error;
         }
 
-        //- /zzz.rs crate:alloc
+        //- /zzz.rs crate:core
 
-        pub mod sync {
-            pub struct Arc;
+        pub mod fmt {
+            pub struct Error;
         }
         "#;
-        check_found_path(code, "alloc::sync::Arc");
+        check_found_path(code, "core::fmt::Error");
     }
 
     #[test]
-    fn prefer_core_paths_over_std() {
-        covers!(prefer_std_paths);
+    fn prefer_alloc_paths_over_std() {
         let code = r#"
-        //- /main.rs crate:main deps:core,std
+        //- /main.rs crate:main deps:alloc,std
         #![no_std]
 
         <|>
 
-        //- /std.rs crate:std deps:core
+        //- /std.rs crate:std deps:alloc
 
-        pub mod fmt {
-            pub use core::fmt::Error;
+        pub mod sync {
+            pub use alloc::sync::Arc;
         }
 
-        //- /zzz.rs crate:core
+        //- /zzz.rs crate:alloc
 
-        pub mod fmt {
-            pub struct Error;
+        pub mod sync {
+            pub struct Arc;
         }
         "#;
-        check_found_path(code, "core::fmt::Error");
+        check_found_path(code, "alloc::sync::Arc");
     }
 
     #[test]
diff --git a/crates/ra_hir_def/src/item_scope.rs b/crates/ra_hir_def/src/item_scope.rs
index 259b9ff03..fc15948ad 100644
--- a/crates/ra_hir_def/src/item_scope.rs
+++ b/crates/ra_hir_def/src/item_scope.rs
@@ -151,13 +151,20 @@ impl ItemScope {
 }
 
 impl PerNs {
-    pub(crate) fn from_def(def: ModuleDefId, v: Visibility) -> PerNs {
+    pub(crate) fn from_def(def: ModuleDefId, v: Visibility, has_constructor: bool) -> PerNs {
         match def {
             ModuleDefId::ModuleId(_) => PerNs::types(def, v),
             ModuleDefId::FunctionId(_) => PerNs::values(def, v),
             ModuleDefId::AdtId(adt) => match adt {
-                AdtId::StructId(_) | AdtId::UnionId(_) => PerNs::both(def, def, v),
+                AdtId::UnionId(_) => PerNs::types(def, v),
                 AdtId::EnumId(_) => PerNs::types(def, v),
+                AdtId::StructId(_) => {
+                    if has_constructor {
+                        PerNs::both(def, def, v)
+                    } else {
+                        PerNs::types(def, v)
+                    }
+                }
             },
             ModuleDefId::EnumVariantId(_) => PerNs::both(def, def, v),
             ModuleDefId::ConstId(_) | ModuleDefId::StaticId(_) => PerNs::values(def, v),
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index 518772e8a..5325a2760 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -46,8 +46,6 @@ pub mod find_path;
 
 #[cfg(test)]
 mod test_db;
-#[cfg(test)]
-mod marks;
 
 use std::hash::Hash;
 
diff --git a/crates/ra_hir_def/src/marks.rs b/crates/ra_hir_def/src/marks.rs
deleted file mode 100644
index daa49d5f1..000000000
--- a/crates/ra_hir_def/src/marks.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//! See test_utils/src/marks.rs
-
-test_utils::marks!(
-    bogus_paths
-    name_res_works_for_broken_modules
-    can_import_enum_variant
-    glob_enum
-    glob_enum_group
-    glob_across_crates
-    std_prelude
-    macro_rules_from_other_crates_are_visible_with_macro_use
-    prelude_is_macro_use
-    macro_dollar_crate_self
-    macro_dollar_crate_other
-    infer_resolve_while_let
-    prefer_std_paths
-);
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 98c74fe25..353a31ad4 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -14,7 +14,7 @@ use ra_cfg::CfgOptions;
 use ra_db::{CrateId, FileId, ProcMacroId};
 use ra_syntax::ast;
 use rustc_hash::FxHashMap;
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     attr::Attrs,
@@ -204,6 +204,7 @@ impl DefCollector<'_> {
                 ast_id: None,
                 krate: Some(krate),
                 kind: MacroDefKind::CustomDerive(expander),
+                local_inner: false,
             };
 
             self.define_proc_macro(name.clone(), macro_id);
@@ -301,7 +302,7 @@ impl DefCollector<'_> {
         );
 
         if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
-            tested_by!(macro_rules_from_other_crates_are_visible_with_macro_use);
+            mark::hit!(macro_rules_from_other_crates_are_visible_with_macro_use);
             self.import_all_macros_exported(current_module_id, m.krate);
         }
     }
@@ -411,10 +412,10 @@ impl DefCollector<'_> {
             match def.take_types() {
                 Some(ModuleDefId::ModuleId(m)) => {
                     if import.is_prelude {
-                        tested_by!(std_prelude);
+                        mark::hit!(std_prelude);
                         self.def_map.prelude = Some(m);
                     } else if m.krate != self.def_map.krate {
-                        tested_by!(glob_across_crates);
+                        mark::hit!(glob_across_crates);
                         // glob import from other crate => we can just import everything once
                         let item_map = self.db.crate_def_map(m.krate);
                         let scope = &item_map[m.local_id].scope;
@@ -460,7 +461,7 @@ impl DefCollector<'_> {
                     }
                 }
                 Some(ModuleDefId::AdtId(AdtId::EnumId(e))) => {
-                    tested_by!(glob_enum);
+                    mark::hit!(glob_enum);
                     // glob import from enum => just import all the variants
 
                     // XXX: urgh, so this works by accident! Here, we look at
@@ -509,7 +510,7 @@ impl DefCollector<'_> {
 
                     self.update(module_id, &[(name, def)], vis);
                 }
-                None => tested_by!(bogus_paths),
+                None => mark::hit!(bogus_paths),
             }
         }
     }
@@ -682,7 +683,7 @@ impl ModCollector<'_, '_> {
         // Prelude module is always considered to be `#[macro_use]`.
         if let Some(prelude_module) = self.def_collector.def_map.prelude {
             if prelude_module.krate != self.def_collector.def_map.krate {
-                tested_by!(prelude_is_macro_use);
+                mark::hit!(prelude_is_macro_use);
                 self.def_collector.import_all_macros_exported(self.module_id, prelude_module.krate);
             }
         }
@@ -829,7 +830,7 @@ impl ModCollector<'_, '_> {
         let module = ModuleId { krate: self.def_collector.def_map.krate, local_id: res };
         let def: ModuleDefId = module.into();
         self.def_collector.def_map.modules[self.module_id].scope.define_def(def);
-        self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis))], vis);
+        self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis, false))], vis);
         res
     }
 
@@ -843,6 +844,8 @@ impl ModCollector<'_, '_> {
         let name = def.name.clone();
         let container = ContainerId::ModuleId(module);
         let vis = &def.visibility;
+        let mut has_constructor = false;
+
         let def: ModuleDefId = match def.kind {
             raw::DefKind::Function(ast_id) => FunctionLoc {
                 container: container.into(),
@@ -850,7 +853,8 @@ impl ModCollector<'_, '_> {
             }
             .intern(self.def_collector.db)
             .into(),
-            raw::DefKind::Struct(ast_id) => {
+            raw::DefKind::Struct(ast_id, mode) => {
+                has_constructor = mode != raw::StructDefKind::Record;
                 StructLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                     .intern(self.def_collector.db)
                     .into()
@@ -893,7 +897,11 @@ impl ModCollector<'_, '_> {
             .def_map
             .resolve_visibility(self.def_collector.db, self.module_id, vis)
             .unwrap_or(Visibility::Public);
-        self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis))], vis)
+        self.def_collector.update(
+            self.module_id,
+            &[(name, PerNs::from_def(def, vis, has_constructor))],
+            vis,
+        )
     }
 
     fn collect_derives(&mut self, attrs: &Attrs, def: &raw::DefData) {
@@ -941,6 +949,7 @@ impl ModCollector<'_, '_> {
                     ast_id: Some(ast_id.ast_id),
                     krate: Some(self.def_collector.def_map.krate),
                     kind: MacroDefKind::Declarative,
+                    local_inner: mac.local_inner,
                 };
                 self.def_collector.define_macro(self.module_id, name.clone(), macro_id, mac.export);
             }
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index 35a0a0c98..19692e70c 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -14,7 +14,7 @@ use std::iter::successors;
 
 use hir_expand::name::Name;
 use ra_db::Edition;
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     db::DefDatabase,
@@ -108,7 +108,7 @@ impl CrateDefMap {
         let mut curr_per_ns: PerNs = match path.kind {
             PathKind::DollarCrate(krate) => {
                 if krate == self.krate {
-                    tested_by!(macro_dollar_crate_self);
+                    mark::hit!(macro_dollar_crate_self);
                     PerNs::types(
                         ModuleId { krate: self.krate, local_id: self.root }.into(),
                         Visibility::Public,
@@ -116,7 +116,7 @@ impl CrateDefMap {
                 } else {
                     let def_map = db.crate_def_map(krate);
                     let module = ModuleId { krate, local_id: def_map.root };
-                    tested_by!(macro_dollar_crate_other);
+                    mark::hit!(macro_dollar_crate_other);
                     PerNs::types(module.into(), Visibility::Public)
                 }
             }
@@ -221,7 +221,7 @@ impl CrateDefMap {
                 }
                 ModuleDefId::AdtId(AdtId::EnumId(e)) => {
                     // enum variant
-                    tested_by!(can_import_enum_variant);
+                    mark::hit!(can_import_enum_variant);
                     let enum_data = db.enum_data(e);
                     match enum_data.variant(&segment) {
                         Some(local_id) => {
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index 39b011ad7..4e628b14d 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -18,7 +18,7 @@ use ra_syntax::{
     ast::{self, AttrsOwner, NameOwner, VisibilityOwner},
     AstNode,
 };
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     attr::Attrs,
@@ -156,9 +156,16 @@ pub(super) struct DefData {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub(super) enum StructDefKind {
+    Record,
+    Tuple,
+    Unit,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub(super) enum DefKind {
     Function(FileAstId<ast::FnDef>),
-    Struct(FileAstId<ast::StructDef>),
+    Struct(FileAstId<ast::StructDef>, StructDefKind),
     Union(FileAstId<ast::UnionDef>),
     Enum(FileAstId<ast::EnumDef>),
     Const(FileAstId<ast::ConstDef>),
@@ -171,7 +178,7 @@ impl DefKind {
     pub fn ast_id(&self) -> FileAstId<ast::ModuleItem> {
         match self {
             DefKind::Function(it) => it.upcast(),
-            DefKind::Struct(it) => it.upcast(),
+            DefKind::Struct(it, _) => it.upcast(),
             DefKind::Union(it) => it.upcast(),
             DefKind::Enum(it) => it.upcast(),
             DefKind::Const(it) => it.upcast(),
@@ -188,6 +195,7 @@ pub(super) struct MacroData {
     pub(super) path: ModPath,
     pub(super) name: Option<Name>,
     pub(super) export: bool,
+    pub(super) local_inner: bool,
     pub(super) builtin: bool,
 }
 
@@ -235,9 +243,14 @@ impl RawItemsCollector {
                 return;
             }
             ast::ModuleItem::StructDef(it) => {
+                let kind = match it.kind() {
+                    ast::StructKind::Record(_) => StructDefKind::Record,
+                    ast::StructKind::Tuple(_) => StructDefKind::Tuple,
+                    ast::StructKind::Unit => StructDefKind::Unit,
+                };
                 let id = self.source_ast_id_map.ast_id(&it);
                 let name = it.name();
-                (DefKind::Struct(id), name)
+                (DefKind::Struct(id, kind), name)
             }
             ast::ModuleItem::UnionDef(it) => {
                 let id = self.source_ast_id_map.ast_id(&it);
@@ -333,7 +346,7 @@ impl RawItemsCollector {
             self.push_item(current_module, attrs, RawItemKind::Module(item));
             return;
         }
-        tested_by!(name_res_works_for_broken_modules);
+        mark::hit!(name_res_works_for_broken_modules);
     }
 
     fn add_use_item(&mut self, current_module: Option<Idx<ModuleData>>, use_item: ast::UseItem) {
@@ -401,14 +414,32 @@ impl RawItemsCollector {
 
         let name = m.name().map(|it| it.as_name());
         let ast_id = self.source_ast_id_map.ast_id(&m);
-        // FIXME: cfg_attr
-        let export = m.attrs().filter_map(|x| x.simple_name()).any(|name| name == "macro_export");
 
         // FIXME: cfg_attr
-        let builtin =
-            m.attrs().filter_map(|x| x.simple_name()).any(|name| name == "rustc_builtin_macro");
+        let export_attr = attrs.by_key("macro_export");
+
+        let export = export_attr.exists();
+        let local_inner = if export {
+            export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it {
+                tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
+                    ident.text.contains("local_inner_macros")
+                }
+                _ => false,
+            })
+        } else {
+            false
+        };
+
+        let builtin = attrs.by_key("rustc_builtin_macro").exists();
 
-        let m = self.raw_items.macros.alloc(MacroData { ast_id, path, name, export, builtin });
+        let m = self.raw_items.macros.alloc(MacroData {
+            ast_id,
+            path,
+            name,
+            export,
+            local_inner,
+            builtin,
+        });
         self.push_item(current_module, attrs, RawItemKind::Macro(m));
     }
 
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index 83120fa36..05cd0297d 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -8,7 +8,7 @@ use std::sync::Arc;
 
 use insta::assert_snapshot;
 use ra_db::{fixture::WithFixture, SourceDatabase};
-use test_utils::covers;
+use test_utils::mark;
 
 use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
 
@@ -67,7 +67,7 @@ fn crate_def_map_smoke_test() {
         ⋮Baz: t v
         ⋮E: t
         ⋮EXT: v
-        ⋮U: t v
+        ⋮U: t
         ⋮ext: v
     "###)
 }
@@ -132,7 +132,7 @@ fn crate_def_map_fn_mod_same_name() {
 
 #[test]
 fn bogus_paths() {
-    covers!(bogus_paths);
+    mark::check!(bogus_paths);
     let map = def_map(
         "
         //- /lib.rs
@@ -247,7 +247,7 @@ fn re_exports() {
 
 #[test]
 fn std_prelude() {
-    covers!(std_prelude);
+    mark::check!(std_prelude);
     let map = def_map(
         "
         //- /main.rs crate:main deps:test_crate
@@ -271,7 +271,7 @@ fn std_prelude() {
 
 #[test]
 fn can_import_enum_variant() {
-    covers!(can_import_enum_variant);
+    mark::check!(can_import_enum_variant);
     let map = def_map(
         "
         //- /lib.rs
diff --git a/crates/ra_hir_def/src/nameres/tests/globs.rs b/crates/ra_hir_def/src/nameres/tests/globs.rs
index ee8df3a26..2b12c0daa 100644
--- a/crates/ra_hir_def/src/nameres/tests/globs.rs
+++ b/crates/ra_hir_def/src/nameres/tests/globs.rs
@@ -152,7 +152,7 @@ fn glob_privacy_2() {
 
 #[test]
 fn glob_across_crates() {
-    covers!(glob_across_crates);
+    mark::check!(glob_across_crates);
     let map = def_map(
         r"
         //- /main.rs crate:main deps:test_crate
@@ -171,7 +171,6 @@ fn glob_across_crates() {
 
 #[test]
 fn glob_privacy_across_crates() {
-    covers!(glob_across_crates);
     let map = def_map(
         r"
         //- /main.rs crate:main deps:test_crate
@@ -191,7 +190,7 @@ fn glob_privacy_across_crates() {
 
 #[test]
 fn glob_enum() {
-    covers!(glob_enum);
+    mark::check!(glob_enum);
     let map = def_map(
         "
         //- /lib.rs
@@ -212,7 +211,7 @@ fn glob_enum() {
 
 #[test]
 fn glob_enum_group() {
-    covers!(glob_enum_group);
+    mark::check!(glob_enum_group);
     let map = def_map(
         r"
         //- /lib.rs
diff --git a/crates/ra_hir_def/src/nameres/tests/macros.rs b/crates/ra_hir_def/src/nameres/tests/macros.rs
index b0befdfbd..84480d9f6 100644
--- a/crates/ra_hir_def/src/nameres/tests/macros.rs
+++ b/crates/ra_hir_def/src/nameres/tests/macros.rs
@@ -19,12 +19,12 @@ fn macro_rules_are_globally_visible() {
     );
     assert_snapshot!(map, @r###"
    ⋮crate
-   ⋮Foo: t v
+   ⋮Foo: t
    ⋮nested: t
    ⋮
    ⋮crate::nested
-   ⋮Bar: t v
-   ⋮Baz: t v
+   ⋮Bar: t
+   ⋮Baz: t
     "###);
 }
 
@@ -91,13 +91,13 @@ fn macro_rules_from_other_crates_are_visible() {
     );
     assert_snapshot!(map, @r###"
    ⋮crate
-   ⋮Bar: t v
-   ⋮Foo: t v
+   ⋮Bar: t
+   ⋮Foo: t
    ⋮bar: t
    ⋮
    ⋮crate::bar
-   ⋮Bar: t v
-   ⋮Foo: t v
+   ⋮Bar: t
+   ⋮Foo: t
    ⋮bar: t
     "###);
 }
@@ -124,13 +124,50 @@ fn macro_rules_export_with_local_inner_macros_are_visible() {
     );
     assert_snapshot!(map, @r###"
    ⋮crate
-   ⋮Bar: t v
-   ⋮Foo: t v
+   ⋮Bar: t
+   ⋮Foo: t
    ⋮bar: t
    ⋮
    ⋮crate::bar
-   ⋮Bar: t v
-   ⋮Foo: t v
+   ⋮Bar: t
+   ⋮Foo: t
+   ⋮bar: t
+    "###);
+}
+
+#[test]
+fn local_inner_macros_makes_local_macros_usable() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:foo
+        foo::structs!(Foo, Bar);
+        mod bar;
+        //- /bar.rs
+        use crate::*;
+        //- /lib.rs crate:foo
+        #[macro_export(local_inner_macros)]
+        macro_rules! structs {
+            ($($i:ident),*) => {
+                inner!($($i),*);
+            }
+        }
+        #[macro_export]
+        macro_rules! inner {
+            ($($i:ident),*) => {
+                $(struct $i { field: u32 } )*
+            }
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Bar: t
+   ⋮Foo: t
+   ⋮bar: t
+   ⋮
+   ⋮crate::bar
+   ⋮Bar: t
+   ⋮Foo: t
    ⋮bar: t
     "###);
 }
@@ -167,7 +204,7 @@ fn unexpanded_macro_should_expand_by_fixedpoint_loop() {
     );
     assert_snapshot!(map, @r###"
    ⋮crate
-   ⋮Foo: t v
+   ⋮Foo: t
    ⋮bar: m
    ⋮foo: m
     "###);
@@ -175,7 +212,7 @@ fn unexpanded_macro_should_expand_by_fixedpoint_loop() {
 
 #[test]
 fn macro_rules_from_other_crates_are_visible_with_macro_use() {
-    covers!(macro_rules_from_other_crates_are_visible_with_macro_use);
+    mark::check!(macro_rules_from_other_crates_are_visible_with_macro_use);
     let map = def_map(
         "
         //- /main.rs crate:main deps:foo
@@ -225,7 +262,7 @@ fn macro_rules_from_other_crates_are_visible_with_macro_use() {
 
 #[test]
 fn prelude_is_macro_use() {
-    covers!(prelude_is_macro_use);
+    mark::check!(prelude_is_macro_use);
     let map = def_map(
         "
         //- /main.rs crate:main deps:foo
@@ -507,8 +544,7 @@ fn path_qualified_macros() {
 
 #[test]
 fn macro_dollar_crate_is_correct_in_item() {
-    covers!(macro_dollar_crate_self);
-    covers!(macro_dollar_crate_other);
+    mark::check!(macro_dollar_crate_self);
     let map = def_map(
         "
         //- /main.rs crate:main deps:foo
@@ -566,7 +602,7 @@ fn macro_dollar_crate_is_correct_in_item() {
 
 #[test]
 fn macro_dollar_crate_is_correct_in_indirect_deps() {
-    covers!(macro_dollar_crate_other);
+    mark::check!(macro_dollar_crate_other);
     // From std
     let map = def_map(
         r#"
diff --git a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
index 37fcdfb8c..b43b294ca 100644
--- a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
@@ -2,7 +2,7 @@ use super::*;
 
 #[test]
 fn name_res_works_for_broken_modules() {
-    covers!(name_res_works_for_broken_modules);
+    mark::check!(name_res_works_for_broken_modules);
     let map = def_map(
         r"
         //- /lib.rs
diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs
index e3d237a0a..6a0c019fd 100644
--- a/crates/ra_hir_def/src/path/lower.rs
+++ b/crates/ra_hir_def/src/path/lower.rs
@@ -116,6 +116,21 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
     }
     segments.reverse();
     generic_args.reverse();
+
+    // handle local_inner_macros :
+    // Basically, even in rustc it is quite hacky:
+    // https://github.com/rust-lang/rust/blob/614f273e9388ddd7804d5cbc80b8865068a3744e/src/librustc_resolve/macros.rs#L456
+    // We follow what it did anyway :)
+    if segments.len() == 1 && kind == PathKind::Plain {
+        if let Some(macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {
+            if macro_call.is_bang() {
+                if let Some(crate_id) = hygiene.local_inner_macros() {
+                    kind = PathKind::DollarCrate(crate_id);
+                }
+            }
+        }
+    }
+
     let mod_path = ModPath { kind, segments };
     return Some(Path { type_anchor, mod_path, generic_args });
 
diff --git a/crates/ra_hir_def/src/path/lower/lower_use.rs b/crates/ra_hir_def/src/path/lower/lower_use.rs
index 5b6854b0f..7cc655487 100644
--- a/crates/ra_hir_def/src/path/lower/lower_use.rs
+++ b/crates/ra_hir_def/src/path/lower/lower_use.rs
@@ -6,7 +6,7 @@ use std::iter;
 use either::Either;
 use hir_expand::{hygiene::Hygiene, name::AsName};
 use ra_syntax::ast::{self, NameOwner};
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::path::{ImportAlias, ModPath, PathKind};
 
@@ -54,7 +54,7 @@ pub(crate) fn lower_use_tree(
         // FIXME: report errors somewhere
         // We get here if we do
         } else if is_glob {
-            tested_by!(glob_enum_group);
+            mark::hit!(glob_enum_group);
             if let Some(prefix) = prefix {
                 cb(prefix, &tree, is_glob, None)
             }
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index 717506358..15fdd9019 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -86,6 +86,7 @@ pub enum ResolveValueResult {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ValueNs {
+    ImplSelf(ImplId),
     LocalBinding(PatId),
     FunctionId(FunctionId),
     ConstId(ConstId),
@@ -291,19 +292,26 @@ impl Resolver {
                 }
                 Scope::GenericParams { .. } => continue,
 
-                Scope::ImplDefScope(impl_) if n_segments > 1 => {
+                Scope::ImplDefScope(impl_) => {
                     if first_name == &name![Self] {
-                        let ty = TypeNs::SelfType(*impl_);
-                        return Some(ResolveValueResult::Partial(ty, 1));
+                        if n_segments > 1 {
+                            let ty = TypeNs::SelfType(*impl_);
+                            return Some(ResolveValueResult::Partial(ty, 1));
+                        } else {
+                            return Some(ResolveValueResult::ValueNs(ValueNs::ImplSelf(*impl_)));
+                        }
                     }
                 }
-                Scope::AdtScope(adt) if n_segments > 1 => {
+                Scope::AdtScope(adt) => {
+                    if n_segments == 1 {
+                        // bare `Self` doesn't work in the value namespace in a struct/enum definition
+                        continue;
+                    }
                     if first_name == &name![Self] {
                         let ty = TypeNs::AdtSelfType(*adt);
                         return Some(ResolveValueResult::Partial(ty, 1));
                     }
                 }
-                Scope::ImplDefScope(_) | Scope::AdtScope(_) => continue,
 
                 Scope::ModuleScope(m) => {
                     let (module_def, idx) = m.crate_def_map.resolve_path(