26 files changed, 662 insertions, 369 deletions
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 753becc3d..2bc34d449 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -12,9 +12,15 @@ use ra_prof::profile;
 use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner};
 use crate::{
-    body::CfgExpander, db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace,
+    body::{CfgExpander, LowerCtx},
-    type_ref::TypeRef, visibility::RawVisibility, EnumId, HasModule, LocalEnumVariantId,
+    db::DefDatabase,
-    LocalFieldId, Lookup, ModuleId, StructId, UnionId, VariantId,
+    src::HasChildSource,
+    src::HasSource,
+    trace::Trace,
+    type_ref::TypeRef,
+    visibility::RawVisibility,
+    EnumId, HasModule, LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StructId, UnionId,
+    VariantId,
 };
 /// Note that we use `StructData` for unions as well!
@@ -111,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 {
@@ -198,11 +211,12 @@ fn lower_struct(
    trace: &mut Trace<FieldData, Either<ast::TupleFieldDef, ast::RecordFieldDef>>,
    ast: &InFile<ast::StructKind>,
 ) -> StructKind {
+    let ctx = LowerCtx::new(db, ast.file_id);
    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(&fd) {
-                if !expander.is_cfg_enabled(&attrs) {
                    continue;
                }
@@ -210,7 +224,7 @@ fn lower_struct(
                    || Either::Left(fd.clone()),
                    || FieldData {
                        name: Name::new_tuple_field(i),
-                        type_ref: TypeRef::from_ast_opt(fd.type_ref()),
+                        type_ref: TypeRef::from_ast_opt(&ctx, fd.type_ref()),
                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                    },
                );
@@ -219,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(&fd) {
-                if !expander.is_cfg_enabled(&attrs) {
                    continue;
                }
@@ -228,7 +241,7 @@ fn lower_struct(
                    || Either::Right(fd.clone()),
                    || FieldData {
                        name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing),
-                        type_ref: TypeRef::from_ast_opt(fd.ascribed_type()),
+                        type_ref: TypeRef::from_ast_opt(&ctx, fd.ascribed_type()),
                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                    },
                );
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 5a86af8ba..8b6c0bede 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -81,7 +81,7 @@ impl Attrs {
        }
    }
-    fn from_attrs_owner(db: &dyn DefDatabase, owner: InFile<&dyn AttrsOwner>) -> Attrs {
+    pub fn from_attrs_owner(db: &dyn DefDatabase, owner: InFile<&dyn AttrsOwner>) -> Attrs {
        let hygiene = Hygiene::new(db.upcast(), owner.file_id);
        Attrs::new(owner.value, &hygiene)
    }
@@ -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 890cefcaf..273036cee 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -15,6 +15,8 @@ use ra_prof::profile;
 use ra_syntax::{ast, AstNode, AstPtr};
 use rustc_hash::FxHashMap;
+pub(crate) use lower::LowerCtx;
 use crate::{
    attr::Attrs,
    db::DefDatabase,
@@ -27,7 +29,7 @@ use crate::{
    AsMacroCall, DefWithBodyId, HasModule, Lookup, ModuleId,
 };
-/// A subset of Exander that only deals with cfg attributes. We only need it to
+/// A subset of Expander that only deals with cfg attributes. We only need it to
 /// avoid cyclic queries in crate def map during enum processing.
 pub(crate) struct CfgExpander {
    cfg_options: CfgOptions,
@@ -58,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)
    }
 }
@@ -139,12 +142,8 @@ impl Expander {
        InFile { file_id: self.current_file_id, value }
    }
-    pub(crate) fn parse_attrs(&self, owner: &dyn ast::AttrsOwner) -> Attrs {
+    pub(crate) fn is_cfg_enabled(&self, owner: &dyn ast::AttrsOwner) -> bool {
-        self.cfg_expander.parse_attrs(owner)
+        self.cfg_expander.is_cfg_enabled(owner)
-    }
-    pub(crate) fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
-        self.cfg_expander.is_cfg_enabled(attrs)
    }
    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 f467ed3fe..f159f80af 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -3,8 +3,9 @@
 use either::Either;
 use hir_expand::{
+    hygiene::Hygiene,
    name::{name, AsName, Name},
-    MacroDefId, MacroDefKind,
+    HirFileId, MacroDefId, MacroDefKind,
 };
 use ra_arena::Arena;
 use ra_syntax::{
@@ -14,7 +15,7 @@ use ra_syntax::{
    },
    AstNode, AstPtr,
 };
-use test_utils::tested_by;
+use test_utils::mark;
 use crate::{
    adt::StructKind,
@@ -26,8 +27,8 @@ use crate::{
        LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
    },
    item_scope::BuiltinShadowMode,
-    path::GenericArgs,
+    path::{GenericArgs, Path},
-    type_ref::{Mutability, TypeRef},
+    type_ref::{Mutability, Rawness, TypeRef},
    AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
    StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
@@ -35,6 +36,23 @@ use crate::{
 use super::{ExprSource, PatSource};
 use ast::AstChildren;
+pub(crate) struct LowerCtx {
+    hygiene: Hygiene,
+}
+impl LowerCtx {
+    pub fn new(db: &dyn DefDatabase, file_id: HirFileId) -> Self {
+        LowerCtx { hygiene: Hygiene::new(db.upcast(), file_id) }
+    }
+    pub fn with_hygiene(hygiene: &Hygiene) -> Self {
+        LowerCtx { hygiene: hygiene.clone() }
+    }
+    pub fn lower_path(&self, ast: ast::Path) -> Option<Path> {
+        Path::from_src(ast, &self.hygiene)
+    }
+}
 pub(super) fn lower(
    db: &dyn DefDatabase,
    def: DefWithBodyId,
@@ -62,7 +80,6 @@ struct ExprCollector<'a> {
    db: &'a dyn DefDatabase,
    def: DefWithBodyId,
    expander: Expander,
    body: Body,
    source_map: BodySourceMap,
 }
@@ -101,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()));
@@ -113,7 +134,7 @@ impl ExprCollector<'_> {
        self.make_expr(expr, Err(SyntheticSyntax))
    }
    fn empty_block(&mut self) -> ExprId {
-        self.alloc_expr_desugared(Expr::Block { statements: Vec::new(), tail: None })
+        self.alloc_expr_desugared(Expr::Block { statements: Vec::new(), tail: None, label: None })
    }
    fn missing_expr(&mut self) -> ExprId {
        self.alloc_expr_desugared(Expr::Missing)
@@ -141,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(&expr) {
-        if !self.expander.is_cfg_enabled(&attrs) {
            return self.missing_expr();
        }
        match expr {
@@ -182,10 +202,29 @@ 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());
-                self.alloc_expr(Expr::Loop { body }, syntax_ptr)
+                self.alloc_expr(
+                    Expr::Loop {
+                        body,
+                        label: e
+                            .label()
+                            .and_then(|l| l.lifetime_token())
+                            .map(|l| Name::new_lifetime(&l)),
+                    },
+                    syntax_ptr,
+                )
            }
            ast::Expr::WhileExpr(e) => {
                let body = self.collect_block_opt(e.loop_body());
@@ -196,29 +235,60 @@ 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();
-                            let break_ = self.alloc_expr_desugared(Expr::Break { expr: None });
+                            let break_ =
+                                self.alloc_expr_desugared(Expr::Break { expr: None, label: None });
                            let arms = vec![
                                MatchArm { pat, expr: body, guard: None },
                                MatchArm { pat: placeholder_pat, expr: break_, guard: None },
                            ];
                            let match_expr =
                                self.alloc_expr_desugared(Expr::Match { expr: match_expr, arms });
-                            return self.alloc_expr(Expr::Loop { body: match_expr }, syntax_ptr);
+                            return self.alloc_expr(
+                                Expr::Loop {
+                                    body: match_expr,
+                                    label: e
+                                        .label()
+                                        .and_then(|l| l.lifetime_token())
+                                        .map(|l| Name::new_lifetime(&l)),
+                                },
+                                syntax_ptr,
+                            );
                        }
                    },
                };
-                self.alloc_expr(Expr::While { condition, body }, syntax_ptr)
+                self.alloc_expr(
+                    Expr::While {
+                        condition,
+                        body,
+                        label: e
+                            .label()
+                            .and_then(|l| l.lifetime_token())
+                            .map(|l| Name::new_lifetime(&l)),
+                    },
+                    syntax_ptr,
+                )
            }
            ast::Expr::ForExpr(e) => {
                let iterable = self.collect_expr_opt(e.iterable());
                let pat = self.collect_pat_opt(e.pat());
                let body = self.collect_block_opt(e.loop_body());
-                self.alloc_expr(Expr::For { iterable, pat, body }, syntax_ptr)
+                self.alloc_expr(
+                    Expr::For {
+                        iterable,
+                        pat,
+                        body,
+                        label: e
+                            .label()
+                            .and_then(|l| l.lifetime_token())
+                            .map(|l| Name::new_lifetime(&l)),
+                    },
+                    syntax_ptr,
+                )
            }
            ast::Expr::CallExpr(e) => {
                let callee = self.collect_expr_opt(e.expr());
@@ -237,7 +307,8 @@ impl ExprCollector<'_> {
                    Vec::new()
                };
                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(GenericArgs::from_ast);
+                let generic_args =
+                    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,
@@ -270,13 +341,16 @@ impl ExprCollector<'_> {
                    .unwrap_or(Expr::Missing);
                self.alloc_expr(path, syntax_ptr)
            }
-            ast::Expr::ContinueExpr(_e) => {
+            ast::Expr::ContinueExpr(e) => self.alloc_expr(
-                // FIXME: labels
+                Expr::Continue { label: e.lifetime_token().map(|l| Name::new_lifetime(&l)) },
-                self.alloc_expr(Expr::Continue, syntax_ptr)
+                syntax_ptr,
-            }
+            ),
            ast::Expr::BreakExpr(e) => {
                let expr = e.expr().map(|e| self.collect_expr(e));
-                self.alloc_expr(Expr::Break { expr }, syntax_ptr)
+                self.alloc_expr(
+                    Expr::Break { expr, label: e.lifetime_token().map(|l| Name::new_lifetime(&l)) },
+                    syntax_ptr,
+                )
            }
            ast::Expr::ParenExpr(e) => {
                let inner = self.collect_expr_opt(e.expr());
@@ -297,8 +371,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(&field) {
-                            if !self.expander.is_cfg_enabled(&attrs) {
                                return None;
                            }
                            let name = field.field_name()?.as_name();
@@ -343,13 +416,26 @@ impl ExprCollector<'_> {
            }
            ast::Expr::CastExpr(e) => {
                let expr = self.collect_expr_opt(e.expr());
-                let type_ref = TypeRef::from_ast_opt(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) => {
                let expr = self.collect_expr_opt(e.expr());
-                let mutability = Mutability::from_mutable(e.mut_token().is_some());
+                let raw_tok = e.raw_token().is_some();
-                self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
+                let mutability = if raw_tok {
+                    if e.mut_token().is_some() {
+                        Mutability::Mut
+                    } else if e.const_token().is_some() {
+                        Mutability::Shared
+                    } else {
+                        unreachable!("parser only remaps to raw_token() if matching mutability token follows")
+                    }
+                } else {
+                    Mutability::from_mutable(e.mut_token().is_some())
+                };
+                let rawness = Rawness::from_raw(raw_tok);
+                self.alloc_expr(Expr::Ref { expr, rawness, mutability }, syntax_ptr)
            }
            ast::Expr::PrefixExpr(e) => {
                let expr = self.collect_expr_opt(e.expr());
@@ -365,12 +451,16 @@ impl ExprCollector<'_> {
                if let Some(pl) = e.param_list() {
                    for param in pl.params() {
                        let pat = self.collect_pat_opt(param.pat());
-                        let type_ref = param.ascribed_type().map(TypeRef::from_ast);
+                        let type_ref =
+                            param.ascribed_type().map(|it| TypeRef::from_ast(&self.ctx(), it));
                        args.push(pat);
                        arg_types.push(type_ref);
                    }
                }
-                let ret_type = e.ret_type().and_then(|r| r.type_ref()).map(TypeRef::from_ast);
+                let ret_type = e
+                    .ret_type()
+                    .and_then(|r| r.type_ref())
+                    .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)
            }
@@ -430,6 +520,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);
@@ -464,19 +555,16 @@ impl ExprCollector<'_> {
        }
    }
-    fn collect_block(&mut self, expr: ast::BlockExpr) -> ExprId {
+    fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
-        let syntax_node_ptr = AstPtr::new(&expr.clone().into());
+        let syntax_node_ptr = AstPtr::new(&block.clone().into());
-        let block = match expr.block() {
-            Some(block) => block,
-            None => return self.alloc_expr(Expr::Missing, syntax_node_ptr),
-        };
        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(TypeRef::from_ast);
+                    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 }
                }
@@ -484,10 +572,11 @@ impl ExprCollector<'_> {
            })
            .collect();
        let tail = block.expr().map(|e| self.collect_expr(e));
-        self.alloc_expr(Expr::Block { statements, tail }, syntax_node_ptr)
+        let label = block.label().and_then(|l| l.lifetime_token()).map(|t| Name::new_lifetime(&t));
+        self.alloc_expr(Expr::Block { statements, tail, label }, 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 {
@@ -542,9 +631,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
+                let has_constructor = match def {
-                    .item_scope
+                    ModuleDefId::AdtId(AdtId::StructId(s)) => {
-                    .push_res(name.as_name(), crate::per_ns::PerNs::from_def(def, vis));
+                        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..e48ff38f9 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -138,10 +138,10 @@ fn compute_block_scopes(
 fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut ExprScopes, scope: ScopeId) {
    scopes.set_scope(expr, scope);
    match &body[expr] {
-        Expr::Block { statements, tail } => {
+        Expr::Block { statements, tail, .. } => {
            compute_block_scopes(&statements, *tail, body, scopes, scope);
        }
-        Expr::For { iterable, pat, body: body_expr } => {
+        Expr::For { iterable, pat, body: body_expr, .. } => {
            compute_expr_scopes(*iterable, body, scopes, scope);
            let scope = scopes.new_scope(scope);
            scopes.add_bindings(body, scope, *pat);
@@ -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 ccb682f9a..807195d25 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -9,12 +9,13 @@ 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,
 };
 use crate::{
    attr::Attrs,
+    body::LowerCtx,
    db::DefDatabase,
    path::{path, AssociatedTypeBinding, GenericArgs, Path},
    src::HasSource,
@@ -33,6 +34,7 @@ pub struct FunctionData {
    /// True if the first param is `self`. This is relevant to decide whether this
    /// can be called as a method.
    pub has_self_param: bool,
+    pub is_unsafe: bool,
    pub visibility: RawVisibility,
 }
@@ -40,13 +42,14 @@ impl FunctionData {
    pub(crate) fn fn_data_query(db: &impl DefDatabase, func: FunctionId) -> Arc<FunctionData> {
        let loc = func.lookup(db);
        let src = loc.source(db);
+        let ctx = LowerCtx::new(db, src.file_id);
        let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
        let mut params = Vec::new();
        let mut has_self_param = false;
        if let Some(param_list) = src.value.param_list() {
            if let Some(self_param) = param_list.self_param() {
                let self_type = if let Some(type_ref) = self_param.ascribed_type() {
-                    TypeRef::from_ast(type_ref)
+                    TypeRef::from_ast(&ctx, type_ref)
                } else {
                    let self_type = TypeRef::Path(name![Self].into());
                    match self_param.kind() {
@@ -63,14 +66,14 @@ impl FunctionData {
                has_self_param = true;
            }
            for param in param_list.params() {
-                let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
+                let type_ref = TypeRef::from_ast_opt(&ctx, param.ascribed_type());
                params.push(type_ref);
            }
        }
        let attrs = Attrs::new(&src.value, &Hygiene::new(db.upcast(), src.file_id));
        let ret_type = if let Some(type_ref) = src.value.ret_type().and_then(|rt| rt.type_ref()) {
-            TypeRef::from_ast(type_ref)
+            TypeRef::from_ast(&ctx, type_ref)
        } else {
            TypeRef::unit()
        };
@@ -83,11 +86,14 @@ impl FunctionData {
            ret_type
        };
+        let is_unsafe = src.value.unsafe_token().is_some();
        let vis_default = RawVisibility::default_for_container(loc.container);
        let visibility =
            RawVisibility::from_ast_with_default(db, vis_default, src.map(|s| s.visibility()));
-        let sig = FunctionData { name, params, ret_type, has_self_param, visibility, attrs };
+        let sig =
+            FunctionData { name, params, ret_type, has_self_param, is_unsafe, visibility, attrs };
        Arc::new(sig)
    }
 }
@@ -122,7 +128,8 @@ impl TypeAliasData {
        let loc = typ.lookup(db);
        let node = loc.source(db);
        let name = node.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let type_ref = node.value.type_ref().map(TypeRef::from_ast);
+        let lower_ctx = LowerCtx::new(db, node.file_id);
+        let type_ref = node.value.type_ref().map(|it| TypeRef::from_ast(&lower_ctx, it));
        let vis_default = RawVisibility::default_for_container(loc.container);
        let visibility = RawVisibility::from_ast_with_default(
            db,
@@ -130,7 +137,7 @@ impl TypeAliasData {
            node.as_ref().map(|n| n.visibility()),
        );
        let bounds = if let Some(bound_list) = node.value.type_bound_list() {
-            bound_list.bounds().map(TypeBound::from_ast).collect()
+            bound_list.bounds().map(|it| TypeBound::from_ast(&lower_ctx, it)).collect()
        } else {
            Vec::new()
        };
@@ -147,51 +154,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() {
+        let mut items = Vec::new();
-            item_list
-                .impl_items()
+        if let Some(item_list) = src.value.item_list() {
-                .map(|item_node| match item_node {
+            let mut expander = Expander::new(db, tr_loc.ast_id.file_id, module_id);
-                    ast::ImplItem::FnDef(it) => {
+            items.extend(collect_items(
-                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
+                db,
-                        let def = FunctionLoc {
+                &mut expander,
-                            container,
+                item_list.assoc_items(),
-                            ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                src.file_id,
-                        }
+                container,
-                        .intern(db)
+            ));
-                        .into();
+            items.extend(collect_items_in_macros(
-                        (name, def)
+                db,
-                    }
+                &mut expander,
-                    ast::ImplItem::ConstDef(it) => {
+                &src.with_value(item_list),
-                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
+                container,
-                        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()
-        };
        Arc::new(TraitData { name, items, auto })
    }
@@ -223,29 +210,28 @@ impl ImplData {
        let _p = profile("impl_data_query");
        let impl_loc = id.lookup(db);
        let src = impl_loc.source(db);
+        let lower_ctx = LowerCtx::new(db, src.file_id);
-        let target_trait = src.value.target_trait().map(TypeRef::from_ast);
+        let target_trait = src.value.target_trait().map(|it| TypeRef::from_ast(&lower_ctx, it));
-        let target_type = TypeRef::from_ast_opt(src.value.target_type());
+        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(
+            items.extend(
-                db,
+                collect_items(db, &mut expander, item_list.assoc_items(), src.file_id, container)
-                &mut expander,
+                    .into_iter()
-                item_list.impl_items(),
+                    .map(|(_, item)| item),
-                src.file_id,
+            );
-                id,
+            items.extend(
-            ));
+                collect_items_in_macros(db, &mut expander, &src.with_value(item_list), container)
-            items.extend(collect_impl_items_in_macros(
+                    .into_iter()
-                db,
+                    .map(|(_, item)| item),
-                &mut expander,
+            );
-                &src.with_value(item_list),
-                id,
-            ));
        }
        let res = ImplData { target_trait, target_type, items, is_negative };
@@ -269,67 +255,90 @@ 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,
        node: InFile<N>,
    ) -> ConstData {
+        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(node.value.ascribed_type());
+        let type_ref = TypeRef::from_ast_opt(&ctx, node.value.ascribed_type());
        let visibility =
            RawVisibility::from_ast_with_default(db, vis_default, node.map(|n| n.visibility()));
        ConstData { name, type_ref, visibility }
    }
 }
-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,
+    container: AssocContainerId,
-) -> Vec<AssocItemId> {
+) -> 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
@@ -338,44 +347,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,
+    container: AssocContainerId,
-) -> Vec<AssocItemId> {
+) -> 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) => {
+            ast::AssocItem::FnDef(it) => {
-                let attrs = expander.parse_attrs(&it);
+                let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                if !expander.is_cfg_enabled(&attrs) {
+                if !expander.is_cfg_enabled(&it) {
                    return None;
                }
-                let def = FunctionLoc {
+                let def = FunctionLoc { container, ast_id: AstId::new(file_id, items.ast_id(&it)) }
-                    container: AssocContainerId::ImplId(id),
+                    .intern(db);
-                    ast_id: AstId::new(file_id, items.ast_id(&it)),
+                Some((name, def.into()))
-                }
-                .intern(db);
-                Some(def.into())
            }
-            ast::ImplItem::ConstDef(it) => {
+            ast::AssocItem::ConstDef(it) => {
-                let def = ConstLoc {
+                let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                    container: AssocContainerId::ImplId(id),
+                let def = ConstLoc { container, ast_id: AstId::new(file_id, items.ast_id(&it)) }
-                    ast_id: AstId::new(file_id, items.ast_id(&it)),
+                    .intern(db);
-                }
+                Some((name, def.into()))
-                .intern(db);
-                Some(def.into())
            }
-            ast::ImplItem::TypeAliasDef(it) => {
+            ast::AssocItem::TypeAliasDef(it) => {
-                let def = TypeAliasLoc {
+                let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                    container: AssocContainerId::ImplId(id),
+                let def =
-                    ast_id: AstId::new(file_id, items.ast_id(&it)),
+                    TypeAliasLoc { container, ast_id: AstId::new(file_id, items.ast_id(&it)) }
-                }
+                        .intern(db);
-                .intern(db);
+                Some((name, def.into()))
-                Some(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)]
+    #[salsa::invoke(StaticData::static_data_query)]
-    fn static_data(&self, konst: StaticId) -> Arc<ConstData>;
+    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..ca49b26d1 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -19,7 +19,7 @@ use ra_syntax::ast::RangeOp;
 use crate::{
    builtin_type::{BuiltinFloat, BuiltinInt},
    path::{GenericArgs, Path},
-    type_ref::{Mutability, TypeRef},
+    type_ref::{Mutability, Rawness, TypeRef},
 };
 pub type ExprId = Idx<Expr>;
@@ -52,18 +52,22 @@ pub enum Expr {
    Block {
        statements: Vec<Statement>,
        tail: Option<ExprId>,
+        label: Option<Name>,
    },
    Loop {
        body: ExprId,
+        label: Option<Name>,
    },
    While {
        condition: ExprId,
        body: ExprId,
+        label: Option<Name>,
    },
    For {
        iterable: ExprId,
        pat: PatId,
        body: ExprId,
+        label: Option<Name>,
    },
    Call {
        callee: ExprId,
@@ -79,9 +83,12 @@ pub enum Expr {
        expr: ExprId,
        arms: Vec<MatchArm>,
    },
-    Continue,
+    Continue {
+        label: Option<Name>,
+    },
    Break {
        expr: Option<ExprId>,
+        label: Option<Name>,
    },
    Return {
        expr: Option<ExprId>,
@@ -101,12 +108,16 @@ pub enum Expr {
    Try {
        expr: ExprId,
    },
+    TryBlock {
+        body: ExprId,
+    },
    Cast {
        expr: ExprId,
        type_ref: TypeRef,
    },
    Ref {
        expr: ExprId,
+        rawness: Rawness,
        mutability: Mutability,
    },
    Box {
@@ -221,7 +232,7 @@ impl Expr {
                    f(*else_branch);
                }
            }
-            Expr::Block { statements, tail } => {
+            Expr::Block { statements, tail, .. } => {
                for stmt in statements {
                    match stmt {
                        Statement::Let { initializer, .. } => {
@@ -236,8 +247,9 @@ impl Expr {
                    f(*expr);
                }
            }
-            Expr::Loop { body } => f(*body),
+            Expr::TryBlock { body } => f(*body),
-            Expr::While { condition, body } => {
+            Expr::Loop { body, .. } => f(*body),
+            Expr::While { condition, body, .. } => {
                f(*condition);
                f(*body);
            }
@@ -263,8 +275,8 @@ impl Expr {
                    f(arm.expr);
                }
            }
-            Expr::Continue => {}
+            Expr::Continue { .. } => {}
-            Expr::Break { expr } | Expr::Return { expr } => {
+            Expr::Break { expr, .. } | Expr::Return { expr } => {
                if let Some(expr) = expr {
                    f(*expr);
                }
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
+        let first_segment = self.segments.first();
-            .first()
+        first_segment == Some(&known::alloc) || first_segment == Some(&known::core)
-            .filter(|&first_segment| {
-                first_segment == &known::alloc || first_segment == &known::core
-            })
-            .is_some()
    }
    fn len(&self) -> usize {
@@ -40,15 +49,7 @@ impl ModPath {
    }
 }
-// FIXME: handle local items
+pub(crate) fn find_path_inner_query(
-/// 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(
    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(
+        let mut path = match db.find_path_inner(
-            db,
            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() {
+    fn prefer_core_paths_over_std() {
-        covers!(prefer_std_paths);
+        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 mod fmt {
-            pub use alloc::sync::Arc;
+            pub use core::fmt::Error;
        }
-        //- /zzz.rs crate:alloc
+        //- /zzz.rs crate:core
-        pub mod sync {
+        pub mod fmt {
-            pub struct Arc;
+            pub struct Error;
        }
        "#;
-        check_found_path(code, "alloc::sync::Arc");
+        check_found_path(code, "core::fmt::Error");
    }
    #[test]
-    fn prefer_core_paths_over_std() {
+    fn prefer_alloc_paths_over_std() {
-        covers!(prefer_std_paths);
        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 mod sync {
-            pub use core::fmt::Error;
+            pub use alloc::sync::Arc;
        }
-        //- /zzz.rs crate:core
+        //- /zzz.rs crate:alloc
-        pub mod fmt {
+        pub mod sync {
-            pub struct Error;
+            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/generics.rs b/crates/ra_hir_def/src/generics.rs
index d850244c4..09a5241f7 100644
--- a/crates/ra_hir_def/src/generics.rs
+++ b/crates/ra_hir_def/src/generics.rs
@@ -15,6 +15,7 @@ use ra_prof::profile;
 use ra_syntax::ast::{self, NameOwner, TypeBoundsOwner, TypeParamsOwner};
 use crate::{
+    body::LowerCtx,
    child_by_source::ChildBySource,
    db::DefDatabase,
    dyn_map::DynMap,
@@ -80,11 +81,13 @@ impl GenericParams {
    fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMap>) {
        let mut generics = GenericParams { types: Arena::default(), where_predicates: Vec::new() };
        let mut sm = ArenaMap::default();
        // FIXME: add `: Sized` bound for everything except for `Self` in traits
        let file_id = match def {
            GenericDefId::FunctionId(it) => {
                let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                // lower `impl Trait` in arguments
                let data = db.function_data(it);
                for param in &data.params {
@@ -94,21 +97,25 @@ impl GenericParams {
            }
            GenericDefId::AdtId(AdtId::StructId(it)) => {
                let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                src.file_id
            }
            GenericDefId::AdtId(AdtId::UnionId(it)) => {
                let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                src.file_id
            }
            GenericDefId::AdtId(AdtId::EnumId(it)) => {
                let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                src.file_id
            }
            GenericDefId::TraitId(it) => {
                let src = it.lookup(db).source(db);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
                // traits get the Self type as an implicit first type parameter
                let self_param_id = generics.types.alloc(TypeParamData {
@@ -120,14 +127,16 @@ impl GenericParams {
                // add super traits as bounds on Self
                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
                let self_param = TypeRef::Path(name![Self].into());
-                generics.fill_bounds(&src.value, self_param);
+                generics.fill_bounds(&lower_ctx, &src.value, self_param);
-                generics.fill(&mut sm, &src.value);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                src.file_id
            }
            GenericDefId::TypeAliasId(it) => {
                let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                src.file_id
            }
            // Note that we don't add `Self` here: in `impl`s, `Self` is not a
@@ -135,7 +144,9 @@ impl GenericParams {
            // type, so this is handled by the resolver.
            GenericDefId::ImplId(it) => {
                let src = it.lookup(db).source(db);
-                generics.fill(&mut sm, &src.value);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
                src.file_id
            }
            // We won't be using this ID anyway
@@ -145,28 +156,38 @@ impl GenericParams {
        (generics, InFile::new(file_id, sm))
    }
-    fn fill(&mut self, sm: &mut SourceMap, node: &dyn TypeParamsOwner) {
+    fn fill(&mut self, lower_ctx: &LowerCtx, sm: &mut SourceMap, node: &dyn TypeParamsOwner) {
        if let Some(params) = node.type_param_list() {
-            self.fill_params(sm, params)
+            self.fill_params(lower_ctx, sm, params)
        }
        if let Some(where_clause) = node.where_clause() {
-            self.fill_where_predicates(where_clause);
+            self.fill_where_predicates(lower_ctx, where_clause);
        }
    }
-    fn fill_bounds(&mut self, node: &dyn ast::TypeBoundsOwner, type_ref: TypeRef) {
+    fn fill_bounds(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        node: &dyn ast::TypeBoundsOwner,
+        type_ref: TypeRef,
+    ) {
        for bound in
            node.type_bound_list().iter().flat_map(|type_bound_list| type_bound_list.bounds())
        {
-            self.add_where_predicate_from_bound(bound, type_ref.clone());
+            self.add_where_predicate_from_bound(lower_ctx, bound, type_ref.clone());
        }
    }
-    fn fill_params(&mut self, sm: &mut SourceMap, params: ast::TypeParamList) {
+    fn fill_params(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        sm: &mut SourceMap,
+        params: ast::TypeParamList,
+    ) {
        for type_param in params.type_params() {
            let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());
            // FIXME: Use `Path::from_src`
-            let default = type_param.default_type().map(TypeRef::from_ast);
+            let default = type_param.default_type().map(|it| TypeRef::from_ast(lower_ctx, it));
            let param = TypeParamData {
                name: Some(name.clone()),
                default,
@@ -176,29 +197,34 @@ impl GenericParams {
            sm.insert(param_id, Either::Right(type_param.clone()));
            let type_ref = TypeRef::Path(name.into());
-            self.fill_bounds(&type_param, type_ref);
+            self.fill_bounds(&lower_ctx, &type_param, type_ref);
        }
    }
-    fn fill_where_predicates(&mut self, where_clause: ast::WhereClause) {
+    fn fill_where_predicates(&mut self, lower_ctx: &LowerCtx, where_clause: ast::WhereClause) {
        for pred in where_clause.predicates() {
            let type_ref = match pred.type_ref() {
                Some(type_ref) => type_ref,
                None => continue,
            };
-            let type_ref = TypeRef::from_ast(type_ref);
+            let type_ref = TypeRef::from_ast(lower_ctx, type_ref);
            for bound in pred.type_bound_list().iter().flat_map(|l| l.bounds()) {
-                self.add_where_predicate_from_bound(bound, type_ref.clone());
+                self.add_where_predicate_from_bound(lower_ctx, bound, type_ref.clone());
            }
        }
    }
-    fn add_where_predicate_from_bound(&mut self, bound: ast::TypeBound, type_ref: TypeRef) {
+    fn add_where_predicate_from_bound(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        bound: ast::TypeBound,
+        type_ref: TypeRef,
+    ) {
        if bound.question_token().is_some() {
            // FIXME: remove this bound
            return;
        }
-        let bound = TypeBound::from_ast(bound);
+        let bound = TypeBound::from_ast(lower_ctx, bound);
        self.where_predicates
            .push(WherePredicate { target: WherePredicateTarget::TypeRef(type_ref), bound });
    }
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/lang_item.rs b/crates/ra_hir_def/src/lang_item.rs
index d96ac8c0a..3516784b8 100644
--- a/crates/ra_hir_def/src/lang_item.rs
+++ b/crates/ra_hir_def/src/lang_item.rs
@@ -73,8 +73,8 @@ pub struct LangItems {
 }
 impl LangItems {
-    pub fn target<'a>(&'a self, item: &str) -> Option<&'a LangItemTarget> {
+    pub fn target(&self, item: &str) -> Option<LangItemTarget> {
-        self.items.get(item)
+        self.items.get(item).copied()
    }
    /// Salsa query. This will look for lang items in a specific crate.
@@ -163,9 +163,13 @@ impl LangItems {
    ) where
        T: Into<AttrDefId> + Copy,
    {
-        let attrs = db.attrs(item.into());
+        if let Some(lang_item_name) = lang_attr(db, item) {
-        if let Some(lang_item_name) = attrs.by_key("lang").string_value() {
+            self.items.entry(lang_item_name).or_insert_with(|| constructor(item));
-            self.items.entry(lang_item_name.clone()).or_insert_with(|| constructor(item));
        }
    }
 }
+pub fn lang_attr(db: &dyn DefDatabase, item: impl Into<AttrDefId> + Copy) -> Option<SmolStr> {
+    let attrs = db.attrs(item.into());
+    attrs.by_key("lang").string_value().cloned()
+}
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..f44baa579 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>),
@@ -168,10 +175,10 @@ pub(super) enum DefKind {
 }
 impl DefKind {
-    pub fn ast_id(&self) -> FileAstId<ast::ModuleItem> {
+    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 =
+        let export_attr = attrs.by_key("macro_export");
-            m.attrs().filter_map(|x| x.simple_name()).any(|name| name == "rustc_builtin_macro");
+        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
+   ⋮Bar: t
-   ⋮Baz: t v
+   ⋮Baz: t
    "###);
 }
@@ -91,13 +91,13 @@ fn macro_rules_from_other_crates_are_visible() {
    );
    assert_snapshot!(map, @r###"
   ⋮crate
-   ⋮Bar: t v
+   ⋮Bar: t
-   ⋮Foo: t v
+   ⋮Foo: t
   ⋮bar: t
   ⋮
   ⋮crate::bar
-   ⋮Bar: t v
+   ⋮Bar: t
-   ⋮Foo: t v
+   ⋮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
+   ⋮Bar: t
-   ⋮Foo: t v
+   ⋮Foo: t
   ⋮bar: t
   ⋮
   ⋮crate::bar
-   ⋮Bar: t v
+   ⋮Bar: t
-   ⋮Foo: t v
+   ⋮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);
+    mark::check!(macro_dollar_crate_self);
-    covers!(macro_dollar_crate_other);
    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.rs b/crates/ra_hir_def/src/path.rs
index 162b3c8c7..e84efe2ab 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -7,6 +7,7 @@ use std::{
    sync::Arc,
 };
+use crate::body::LowerCtx;
 use hir_expand::{
    hygiene::Hygiene,
    name::{AsName, Name},
@@ -244,8 +245,8 @@ impl<'a> PathSegments<'a> {
 }
 impl GenericArgs {
-    pub(crate) fn from_ast(node: ast::TypeArgList) -> Option<GenericArgs> {
+    pub(crate) fn from_ast(lower_ctx: &LowerCtx, node: ast::TypeArgList) -> Option<GenericArgs> {
-        lower::lower_generic_args(node)
+        lower::lower_generic_args(lower_ctx, node)
    }
    pub(crate) fn empty() -> GenericArgs {
diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs
index 9ec2e0dcd..6a0c019fd 100644
--- a/crates/ra_hir_def/src/path/lower.rs
+++ b/crates/ra_hir_def/src/path/lower.rs
@@ -13,6 +13,7 @@ use ra_syntax::ast::{self, AstNode, TypeAscriptionOwner, TypeBoundsOwner};
 use super::AssociatedTypeBinding;
 use crate::{
+    body::LowerCtx,
    path::{GenericArg, GenericArgs, ModPath, Path, PathKind},
    type_ref::{TypeBound, TypeRef},
 };
@@ -26,6 +27,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
    let mut type_anchor = None;
    let mut segments = Vec::new();
    let mut generic_args = Vec::new();
+    let ctx = LowerCtx::with_hygiene(hygiene);
    loop {
        let segment = path.segment()?;
@@ -40,9 +42,10 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
                    Either::Left(name) => {
                        let args = segment
                            .type_arg_list()
-                            .and_then(lower_generic_args)
+                            .and_then(|it| lower_generic_args(&ctx, it))
                            .or_else(|| {
                                lower_generic_args_from_fn_path(
+                                    &ctx,
                                    segment.param_list(),
                                    segment.ret_type(),
                                )
@@ -60,7 +63,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
            ast::PathSegmentKind::Type { type_ref, trait_ref } => {
                assert!(path.qualifier().is_none()); // this can only occur at the first segment
-                let self_type = TypeRef::from_ast(type_ref?);
+                let self_type = TypeRef::from_ast(&ctx, type_ref?);
                match trait_ref {
                    // <T>::foo
@@ -113,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 });
@@ -128,10 +146,13 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
    }
 }
-pub(super) fn lower_generic_args(node: ast::TypeArgList) -> Option<GenericArgs> {
+pub(super) fn lower_generic_args(
+    lower_ctx: &LowerCtx,
+    node: ast::TypeArgList,
+) -> Option<GenericArgs> {
    let mut args = Vec::new();
    for type_arg in node.type_args() {
-        let type_ref = TypeRef::from_ast_opt(type_arg.type_ref());
+        let type_ref = TypeRef::from_ast_opt(lower_ctx, type_arg.type_ref());
        args.push(GenericArg::Type(type_ref));
    }
    // lifetimes ignored for now
@@ -140,9 +161,9 @@ pub(super) fn lower_generic_args(node: ast::TypeArgList) -> Option<GenericArgs>
        let assoc_type_arg: ast::AssocTypeArg = assoc_type_arg;
        if let Some(name_ref) = assoc_type_arg.name_ref() {
            let name = name_ref.as_name();
-            let type_ref = assoc_type_arg.type_ref().map(TypeRef::from_ast);
+            let type_ref = assoc_type_arg.type_ref().map(|it| TypeRef::from_ast(lower_ctx, it));
            let bounds = if let Some(l) = assoc_type_arg.type_bound_list() {
-                l.bounds().map(TypeBound::from_ast).collect()
+                l.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect()
            } else {
                Vec::new()
            };
@@ -159,6 +180,7 @@ pub(super) fn lower_generic_args(node: ast::TypeArgList) -> Option<GenericArgs>
 /// Collect `GenericArgs` from the parts of a fn-like path, i.e. `Fn(X, Y)
 /// -> Z` (which desugars to `Fn<(X, Y), Output=Z>`).
 fn lower_generic_args_from_fn_path(
+    ctx: &LowerCtx,
    params: Option<ast::ParamList>,
    ret_type: Option<ast::RetType>,
 ) -> Option<GenericArgs> {
@@ -167,14 +189,14 @@ fn lower_generic_args_from_fn_path(
    if let Some(params) = params {
        let mut param_types = Vec::new();
        for param in params.params() {
-            let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
+            let type_ref = TypeRef::from_ast_opt(&ctx, param.ascribed_type());
            param_types.push(type_ref);
        }
        let arg = GenericArg::Type(TypeRef::Tuple(param_types));
        args.push(arg);
    }
    if let Some(ret_type) = ret_type {
-        let type_ref = TypeRef::from_ast_opt(ret_type.type_ref());
+        let type_ref = TypeRef::from_ast_opt(&ctx, ret_type.type_ref());
        bindings.push(AssociatedTypeBinding {
            name: name![Output],
            type_ref: Some(type_ref),
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_);
+                        if n_segments > 1 {
-                        return Some(ResolveValueResult::Partial(ty, 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(
diff --git a/crates/ra_hir_def/src/type_ref.rs b/crates/ra_hir_def/src/type_ref.rs
index f308c6bdf..86a77b704 100644
--- a/crates/ra_hir_def/src/type_ref.rs
+++ b/crates/ra_hir_def/src/type_ref.rs
@@ -3,7 +3,7 @@
 use ra_syntax::ast::{self, TypeAscriptionOwner, TypeBoundsOwner};
-use crate::path::Path;
+use crate::{body::LowerCtx, path::Path};
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub enum Mutability {
@@ -35,6 +35,22 @@ impl Mutability {
    }
 }
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub enum Rawness {
+    RawPtr,
+    Ref,
+}
+impl Rawness {
+    pub fn from_raw(is_raw: bool) -> Rawness {
+        if is_raw {
+            Rawness::RawPtr
+        } else {
+            Rawness::Ref
+        }
+    }
+}
 /// Compare ty::Ty
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub enum TypeRef {
@@ -64,30 +80,34 @@ pub enum TypeBound {
 impl TypeRef {
    /// Converts an `ast::TypeRef` to a `hir::TypeRef`.
-    pub(crate) fn from_ast(node: ast::TypeRef) -> Self {
+    pub(crate) fn from_ast(ctx: &LowerCtx, node: ast::TypeRef) -> Self {
        match node {
-            ast::TypeRef::ParenType(inner) => TypeRef::from_ast_opt(inner.type_ref()),
+            ast::TypeRef::ParenType(inner) => TypeRef::from_ast_opt(&ctx, inner.type_ref()),
            ast::TypeRef::TupleType(inner) => {
-                TypeRef::Tuple(inner.fields().map(TypeRef::from_ast).collect())
+                TypeRef::Tuple(inner.fields().map(|it| TypeRef::from_ast(ctx, it)).collect())
            }
            ast::TypeRef::NeverType(..) => TypeRef::Never,
            ast::TypeRef::PathType(inner) => {
                // FIXME: Use `Path::from_src`
-                inner.path().and_then(Path::from_ast).map(TypeRef::Path).unwrap_or(TypeRef::Error)
+                inner
+                    .path()
+                    .and_then(|it| ctx.lower_path(it))
+                    .map(TypeRef::Path)
+                    .unwrap_or(TypeRef::Error)
            }
            ast::TypeRef::PointerType(inner) => {
-                let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
+                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.type_ref());
                let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                TypeRef::RawPtr(Box::new(inner_ty), mutability)
            }
            ast::TypeRef::ArrayType(inner) => {
-                TypeRef::Array(Box::new(TypeRef::from_ast_opt(inner.type_ref())))
+                TypeRef::Array(Box::new(TypeRef::from_ast_opt(&ctx, inner.type_ref())))
            }
            ast::TypeRef::SliceType(inner) => {
-                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(inner.type_ref())))
+                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(&ctx, inner.type_ref())))
            }
            ast::TypeRef::ReferenceType(inner) => {
-                let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
+                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.type_ref());
                let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                TypeRef::Reference(Box::new(inner_ty), mutability)
            }
@@ -96,10 +116,13 @@ impl TypeRef {
                let ret_ty = inner
                    .ret_type()
                    .and_then(|rt| rt.type_ref())
-                    .map(TypeRef::from_ast)
+                    .map(|it| TypeRef::from_ast(ctx, it))
                    .unwrap_or_else(|| TypeRef::Tuple(Vec::new()));
                let mut params = if let Some(pl) = inner.param_list() {
-                    pl.params().map(|p| p.ascribed_type()).map(TypeRef::from_ast_opt).collect()
+                    pl.params()
+                        .map(|p| p.ascribed_type())
+                        .map(|it| TypeRef::from_ast_opt(&ctx, it))
+                        .collect()
                } else {
                    Vec::new()
                };
@@ -107,19 +130,19 @@ impl TypeRef {
                TypeRef::Fn(params)
            }
            // for types are close enough for our purposes to the inner type for now...
-            ast::TypeRef::ForType(inner) => TypeRef::from_ast_opt(inner.type_ref()),
+            ast::TypeRef::ForType(inner) => TypeRef::from_ast_opt(&ctx, inner.type_ref()),
            ast::TypeRef::ImplTraitType(inner) => {
-                TypeRef::ImplTrait(type_bounds_from_ast(inner.type_bound_list()))
+                TypeRef::ImplTrait(type_bounds_from_ast(ctx, inner.type_bound_list()))
            }
            ast::TypeRef::DynTraitType(inner) => {
-                TypeRef::DynTrait(type_bounds_from_ast(inner.type_bound_list()))
+                TypeRef::DynTrait(type_bounds_from_ast(ctx, inner.type_bound_list()))
            }
        }
    }
-    pub(crate) fn from_ast_opt(node: Option<ast::TypeRef>) -> Self {
+    pub(crate) fn from_ast_opt(ctx: &LowerCtx, node: Option<ast::TypeRef>) -> Self {
        if let Some(node) = node {
-            TypeRef::from_ast(node)
+            TypeRef::from_ast(ctx, node)
        } else {
            TypeRef::Error
        }
@@ -180,24 +203,27 @@ impl TypeRef {
    }
 }
-pub(crate) fn type_bounds_from_ast(type_bounds_opt: Option<ast::TypeBoundList>) -> Vec<TypeBound> {
+pub(crate) fn type_bounds_from_ast(
+    lower_ctx: &LowerCtx,
+    type_bounds_opt: Option<ast::TypeBoundList>,
+) -> Vec<TypeBound> {
    if let Some(type_bounds) = type_bounds_opt {
-        type_bounds.bounds().map(TypeBound::from_ast).collect()
+        type_bounds.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect()
    } else {
        vec![]
    }
 }
 impl TypeBound {
-    pub(crate) fn from_ast(node: ast::TypeBound) -> Self {
+    pub(crate) fn from_ast(ctx: &LowerCtx, node: ast::TypeBound) -> Self {
        match node.kind() {
            ast::TypeBoundKind::PathType(path_type) => {
                let path = match path_type.path() {
                    Some(p) => p,
                    None => return TypeBound::Error,
                };
-                // FIXME: Use `Path::from_src`
-                let path = match Path::from_ast(path) {
+                let path = match ctx.lower_path(path) {
                    Some(p) => p,
                    None => return TypeBound::Error,
                };