47 files changed, 1050 insertions, 1047 deletions
diff --git a/crates/ra_assists/src/assists/add_import.rs b/crates/ra_assists/src/assists/add_import.rs
index ceffee9b8..b8752cbad 100644
--- a/crates/ra_assists/src/assists/add_import.rs
+++ b/crates/ra_assists/src/assists/add_import.rs
@@ -590,7 +590,7 @@ fn collect_hir_path_segments(path: &hir::Path) -> Option<Vec<SmolStr>> {
            }
            ps.push(chain.into());
        }
-        hir::PathKind::Type(_) | hir::PathKind::DollarCrate(_) => return None,
+        hir::PathKind::DollarCrate(_) => return None,
    }
    ps.extend(path.segments().iter().map(|it| it.name.to_string().into()));
    Some(ps)
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 7850ea9a7..ecf883272 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -11,9 +11,9 @@ use hir_def::{
    per_ns::PerNs,
    resolver::HasResolver,
    type_ref::{Mutability, TypeRef},
-    AdtId, ConstId, ContainerId, DefWithBodyId, EnumId, FunctionId, HasModule, ImplId,
+    AdtId, ConstId, DefWithBodyId, EnumId, FunctionId, HasModule, ImplId, LocalEnumVariantId,
-    LocalEnumVariantId, LocalImportId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId,
+    LocalImportId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId, StructId,
-    StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
+    TraitId, TypeAliasId, TypeParamId, UnionId,
 };
 use hir_expand::{
    diagnostics::DiagnosticSink,
@@ -269,7 +269,7 @@ pub struct Struct {
 impl Struct {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        Module { id: self.id.lookup(db).container }
+        Module { id: self.id.lookup(db).container.module(db) }
    }
    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
@@ -290,7 +290,7 @@ impl Struct {
    }
    pub fn ty(self, db: &impl HirDatabase) -> Type {
-        Type::from_def(db, self.id.lookup(db).container.krate, self.id)
+        Type::from_def(db, self.id.lookup(db).container.module(db).krate, self.id)
    }
    fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
@@ -309,11 +309,11 @@ impl Union {
    }
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        Module { id: self.id.lookup(db).container }
+        Module { id: self.id.lookup(db).container.module(db) }
    }
    pub fn ty(self, db: &impl HirDatabase) -> Type {
-        Type::from_def(db, self.id.lookup(db).container.krate, self.id)
+        Type::from_def(db, self.id.lookup(db).container.module(db).krate, self.id)
    }
    pub fn fields(self, db: &impl HirDatabase) -> Vec<StructField> {
@@ -337,7 +337,7 @@ pub struct Enum {
 impl Enum {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        Module { id: self.id.lookup(db).container }
+        Module { id: self.id.lookup(db).container.module(db) }
    }
    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
@@ -357,7 +357,7 @@ impl Enum {
    }
    pub fn ty(self, db: &impl HirDatabase) -> Type {
-        Type::from_def(db, self.id.lookup(db).container.krate, self.id)
+        Type::from_def(db, self.id.lookup(db).container.module(db).krate, self.id)
    }
 }
@@ -529,30 +529,6 @@ impl Const {
    pub fn name(self, db: &impl HirDatabase) -> Option<Name> {
        db.const_data(self.id).name.clone()
    }
-    /// The containing impl block, if this is a type alias.
-    pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        match self.container(db) {
-            Some(Container::ImplBlock(it)) => Some(it),
-            _ => None,
-        }
-    }
-    /// The containing trait, if this is a trait type alias definition.
-    pub fn parent_trait(self, db: &impl DefDatabase) -> Option<Trait> {
-        match self.container(db) {
-            Some(Container::Trait(it)) => Some(it),
-            _ => None,
-        }
-    }
-    pub fn container(self, db: &impl DefDatabase) -> Option<Container> {
-        match self.id.lookup(db).container {
-            ContainerId::TraitId(it) => Some(Container::Trait(it.into())),
-            ContainerId::ImplId(it) => Some(Container::ImplBlock(it.into())),
-            ContainerId::ModuleId(_) => None,
-        }
-    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -577,7 +553,7 @@ pub struct Trait {
 impl Trait {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        Module { id: self.id.lookup(db).container }
+        Module { id: self.id.lookup(db).container.module(db) }
    }
    pub fn name(self, db: &impl DefDatabase) -> Name {
@@ -612,30 +588,6 @@ impl TypeAlias {
        Some(self.module(db).krate())
    }
-    /// The containing impl block, if this is a type alias.
-    pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        match self.container(db) {
-            Some(Container::ImplBlock(it)) => Some(it),
-            _ => None,
-        }
-    }
-    /// The containing trait, if this is a trait type alias definition.
-    pub fn parent_trait(self, db: &impl DefDatabase) -> Option<Trait> {
-        match self.container(db) {
-            Some(Container::Trait(it)) => Some(it),
-            _ => None,
-        }
-    }
-    pub fn container(self, db: &impl DefDatabase) -> Option<Container> {
-        match self.id.lookup(db).container {
-            ContainerId::TraitId(it) => Some(Container::Trait(it.into())),
-            ContainerId::ImplId(it) => Some(Container::ImplBlock(it.into())),
-            ContainerId::ModuleId(_) => None,
-        }
-    }
    pub fn type_ref(self, db: &impl DefDatabase) -> Option<TypeRef> {
        db.type_alias_data(self.id).type_ref.clone()
    }
@@ -654,14 +606,6 @@ pub struct MacroDef {
    pub(crate) id: MacroDefId,
 }
-impl MacroDef {}
-pub enum Container {
-    Trait(Trait),
-    ImplBlock(ImplBlock),
-}
-impl_froms!(Container: Trait, ImplBlock);
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum AssocItem {
    Function(Function),
@@ -810,7 +754,7 @@ impl ImplBlock {
        let environment = TraitEnvironment::lower(db, &resolver);
        let ty = Ty::from_hir(db, &resolver, &impl_data.target_type);
        Type {
-            krate: self.id.lookup(db).container.krate,
+            krate: self.id.lookup(db).container.module(db).krate,
            ty: InEnvironment { value: ty, environment },
        }
    }
@@ -824,7 +768,7 @@ impl ImplBlock {
    }
    pub fn module(&self, db: &impl DefDatabase) -> Module {
-        self.id.lookup(db).container.into()
+        self.id.lookup(db).container.module(db).into()
    }
    pub fn krate(&self, db: &impl DefDatabase) -> Crate {
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index 7abb4bd75..42ca55fe7 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -1,8 +1,10 @@
-//! FIXME: write short doc here
+//! Finds a corresponding hir data structure for a syntax node in a specific
+//! file.
 use hir_def::{
    child_by_source::ChildBySource, dyn_map::DynMap, keys, keys::Key, nameres::ModuleSource,
-    ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, ModuleId, StaticId, StructId,
+    ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, ModuleId,
-    TraitId, TypeAliasId, UnionId, VariantId,
+    StaticId, StructId, TraitId, TypeAliasId, UnionId, VariantId,
 };
 use hir_expand::{name::AsName, AstId, MacroDefId, MacroDefKind};
 use ra_syntax::{
@@ -11,14 +13,14 @@ use ra_syntax::{
 };
 use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
+    db::{DefDatabase, HirDatabase},
    Const, DefWithBody, Enum, EnumVariant, FieldSource, Function, ImplBlock, InFile, Local,
    MacroDef, Module, Static, Struct, StructField, Trait, TypeAlias, TypeParam, Union,
 };
 pub trait FromSource: Sized {
    type Ast;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self>;
+    fn from_source(db: &impl DefDatabase, src: InFile<Self::Ast>) -> Option<Self>;
 }
 pub trait FromSourceByContainer: Sized {
@@ -32,7 +34,7 @@ where
    T: From<<T as FromSourceByContainer>::Id>,
 {
    type Ast = <T as FromSourceByContainer>::Ast;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
+    fn from_source(db: &impl DefDatabase, src: InFile<Self::Ast>) -> Option<Self> {
        analyze_container(db, src.as_ref().map(|it| it.syntax()))[T::KEY]
            .get(&src)
            .copied()
@@ -64,7 +66,7 @@ from_source_by_container_impls![
 impl FromSource for MacroDef {
    type Ast = ast::MacroCall;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
+    fn from_source(db: &impl DefDatabase, src: InFile<Self::Ast>) -> Option<Self> {
        let kind = MacroDefKind::Declarative;
        let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
@@ -80,7 +82,7 @@ impl FromSource for MacroDef {
 impl FromSource for EnumVariant {
    type Ast = ast::EnumVariant;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
+    fn from_source(db: &impl DefDatabase, src: InFile<Self::Ast>) -> Option<Self> {
        let parent_enum = src.value.parent_enum();
        let src_enum = InFile { file_id: src.file_id, value: parent_enum };
        let parent_enum = Enum::from_source(db, src_enum)?;
@@ -93,7 +95,7 @@ impl FromSource for EnumVariant {
 impl FromSource for StructField {
    type Ast = FieldSource;
-    fn from_source(db: &(impl DefDatabase + AstDatabase), src: InFile<Self::Ast>) -> Option<Self> {
+    fn from_source(db: &impl DefDatabase, src: InFile<Self::Ast>) -> Option<Self> {
        let src = src.as_ref();
        // FIXME this is buggy
@@ -212,29 +214,43 @@ impl Module {
 }
 fn analyze_container(db: &impl DefDatabase, src: InFile<&SyntaxNode>) -> DynMap {
-    _analyze_container(db, src).unwrap_or_default()
+    return child_by_source(db, src).unwrap_or_default();
-}
-fn _analyze_container(db: &impl DefDatabase, src: InFile<&SyntaxNode>) -> Option<DynMap> {
+    fn child_by_source(db: &impl DefDatabase, src: InFile<&SyntaxNode>) -> Option<DynMap> {
-    // FIXME: this doesn't try to handle nested declarations
+        for container in src.value.ancestors().skip(1) {
-    for container in src.value.ancestors().skip(1) {
+            let res = match_ast! {
-        let res = match_ast! {
+                match container {
-            match container {
+                    ast::TraitDef(it) => {
-                ast::TraitDef(it) => {
+                        let def = Trait::from_source(db, src.with_value(it))?;
-                    let c = Trait::from_source(db, src.with_value(it))?;
+                        def.id.child_by_source(db)
-                    c.id.child_by_source(db)
+                    },
-                },
+                    ast::ImplBlock(it) => {
-                ast::ImplBlock(it) => {
+                        let def = ImplBlock::from_source(db, src.with_value(it))?;
-                    let c = ImplBlock::from_source(db, src.with_value(it))?;
+                        def.id.child_by_source(db)
-                    c.id.child_by_source(db)
+                    },
-                 },
+                    ast::FnDef(it) => {
-                _ => { continue },
+                        let def = Function::from_source(db, src.with_value(it))?;
-            }
+                        DefWithBodyId::from(def.id)
-        };
+                            .child_by_source(db)
-        return Some(res);
+                    },
-    }
+                    ast::StaticDef(it) => {
+                        let def = Static::from_source(db, src.with_value(it))?;
+                        DefWithBodyId::from(def.id)
+                            .child_by_source(db)
+                    },
+                    ast::ConstDef(it) => {
+                        let def = Const::from_source(db, src.with_value(it))?;
+                        DefWithBodyId::from(def.id)
+                            .child_by_source(db)
+                    },
+                    _ => { continue },
+                }
+            };
+            return Some(res);
+        }
-    let module_source = ModuleSource::from_child_node(db, src);
+        let module_source = ModuleSource::from_child_node(db, src);
-    let c = Module::from_definition(db, src.with_value(module_source))?;
+        let c = Module::from_definition(db, src.with_value(module_source))?;
-    Some(c.id.child_by_source(db))
+        Some(c.id.child_by_source(db))
+    }
 }
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 2e52a1f5c..7f9aef770 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -39,7 +39,7 @@ mod from_source;
 pub use crate::{
    code_model::{
-        Adt, AssocItem, AttrDef, Const, Container, Crate, CrateDependency, DefWithBody, Docs, Enum,
+        Adt, AssocItem, AttrDef, Const, Crate, CrateDependency, DefWithBody, Docs, Enum,
        EnumVariant, FieldSource, Function, GenericDef, HasAttrs, ImplBlock, Import, Local,
        MacroDef, Module, ModuleDef, ScopeDef, Static, Struct, StructField, Trait, Type, TypeAlias,
        TypeParam, Union, VariantDef,
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index d326169b3..b60a6b87e 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -237,7 +237,13 @@ impl SourceAnalyzer {
    }
    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<crate::StructField> {
-        let expr_id = self.expr_id(&field.expr()?)?;
+        let expr_id = match field.expr() {
+            Some(it) => self.expr_id(&it)?,
+            None => {
+                let src = InFile { file_id: self.file_id, value: field };
+                self.body_source_map.as_ref()?.field_init_shorthand_expr(src)?
+            }
+        };
        self.infer.as_ref()?.record_field_resolution(expr_id).map(|it| it.into())
    }
diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index b1923bbf2..2c368f690 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -13,6 +13,7 @@ once_cell = "1.0.1"
 rustc-hash = "1.0"
 either = "1.5"
 anymap = "0.12"
+drop_bomb = "0.1.4"
 ra_arena = { path = "../ra_arena" }
 ra_db = { path = "../ra_db" }
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 7787cb87f..401fe0b9b 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -3,10 +3,13 @@
 mod lower;
 pub mod scope;
-use std::{ops::Index, sync::Arc};
+use std::{mem, ops::Index, sync::Arc};
+use drop_bomb::DropBomb;
 use either::Either;
-use hir_expand::{hygiene::Hygiene, AstId, HirFileId, InFile, MacroCallKind, MacroDefId};
+use hir_expand::{
+    ast_id_map::AstIdMap, hygiene::Hygiene, AstId, HirFileId, InFile, MacroCallKind, MacroDefId,
+};
 use ra_arena::{map::ArenaMap, Arena};
 use ra_syntax::{ast, AstNode, AstPtr};
 use rustc_hash::FxHashMap;
@@ -15,15 +18,16 @@ use crate::{
    db::DefDatabase,
    expr::{Expr, ExprId, Pat, PatId},
    nameres::{BuiltinShadowMode, CrateDefMap},
-    path::Path,
+    path::{ModPath, Path},
    src::HasSource,
-    DefWithBodyId, HasModule, Lookup, ModuleId,
+    DefWithBodyId, HasModule, Lookup, ModuleDefId, ModuleId,
 };
 struct Expander {
    crate_def_map: Arc<CrateDefMap>,
    current_file_id: HirFileId,
    hygiene: Hygiene,
+    ast_id_map: Arc<AstIdMap>,
    module: ModuleId,
 }
@@ -31,7 +35,8 @@ impl Expander {
    fn new(db: &impl DefDatabase, current_file_id: HirFileId, module: ModuleId) -> Expander {
        let crate_def_map = db.crate_def_map(module.krate);
        let hygiene = Hygiene::new(db, current_file_id);
-        Expander { crate_def_map, current_file_id, hygiene, module }
+        let ast_id_map = db.ast_id_map(current_file_id);
+        Expander { crate_def_map, current_file_id, hygiene, ast_id_map, module }
    }
    fn enter_expand(
@@ -44,7 +49,7 @@ impl Expander {
            db.ast_id_map(self.current_file_id).ast_id(&macro_call),
        );
-        if let Some(path) = macro_call.path().and_then(|path| self.parse_path(path)) {
+        if let Some(path) = macro_call.path().and_then(|path| self.parse_mod_path(path)) {
            if let Some(def) = self.resolve_path_as_macro(db, &path) {
                let call_id = def.as_call_id(db, MacroCallKind::FnLike(ast_id));
                let file_id = call_id.as_file();
@@ -52,9 +57,14 @@ impl Expander {
                    if let Some(expr) = ast::Expr::cast(node) {
                        log::debug!("macro expansion {:#?}", expr.syntax());
-                        let mark = Mark { file_id: self.current_file_id };
+                        let mark = Mark {
+                            file_id: self.current_file_id,
+                            ast_id_map: mem::take(&mut self.ast_id_map),
+                            bomb: DropBomb::new("expansion mark dropped"),
+                        };
                        self.hygiene = Hygiene::new(db, file_id);
                        self.current_file_id = file_id;
+                        self.ast_id_map = db.ast_id_map(file_id);
                        return Some((mark, expr));
                    }
@@ -67,10 +77,11 @@ impl Expander {
        None
    }
-    fn exit(&mut self, db: &impl DefDatabase, mark: Mark) {
+    fn exit(&mut self, db: &impl DefDatabase, mut mark: Mark) {
        self.hygiene = Hygiene::new(db, mark.file_id);
        self.current_file_id = mark.file_id;
-        std::mem::forget(mark);
+        self.ast_id_map = mem::take(&mut mark.ast_id_map);
+        mark.bomb.defuse();
    }
    fn to_source<T>(&self, value: T) -> InFile<T> {
@@ -81,24 +92,27 @@ impl Expander {
        Path::from_src(path, &self.hygiene)
    }
-    fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &Path) -> Option<MacroDefId> {
+    fn parse_mod_path(&mut self, path: ast::Path) -> Option<ModPath> {
+        ModPath::from_src(path, &self.hygiene)
+    }
+    fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &ModPath) -> Option<MacroDefId> {
        self.crate_def_map
-            .resolve_path(db, self.module.local_id, path.mod_path(), BuiltinShadowMode::Other)
+            .resolve_path(db, self.module.local_id, path, BuiltinShadowMode::Other)
            .0
            .take_macros()
    }
+    fn ast_id<N: AstNode>(&self, item: &N) -> AstId<N> {
+        let file_local_id = self.ast_id_map.ast_id(item);
+        AstId::new(self.current_file_id, file_local_id)
+    }
 }
 struct Mark {
    file_id: HirFileId,
-}
+    ast_id_map: Arc<AstIdMap>,
+    bomb: DropBomb,
-impl Drop for Mark {
-    fn drop(&mut self) {
-        if !std::thread::panicking() {
-            panic!("dropped mark")
-        }
-    }
 }
 /// The body of an item (function, const etc.).
@@ -115,6 +129,7 @@ pub struct Body {
    pub params: Vec<PatId>,
    /// The `ExprId` of the actual body expression.
    pub body_expr: ExprId,
+    pub defs: Vec<ModuleDefId>,
 }
 pub type ExprPtr = Either<AstPtr<ast::Expr>, AstPtr<ast::RecordField>>;
@@ -169,7 +184,7 @@ impl Body {
            }
        };
        let expander = Expander::new(db, file_id, module);
-        let (body, source_map) = Body::new(db, expander, params, body);
+        let (body, source_map) = Body::new(db, def, expander, params, body);
        (Arc::new(body), Arc::new(source_map))
    }
@@ -179,11 +194,12 @@ impl Body {
    fn new(
        db: &impl DefDatabase,
+        def: DefWithBodyId,
        expander: Expander,
        params: Option<ast::ParamList>,
        body: Option<ast::Expr>,
    ) -> (Body, BodySourceMap) {
-        lower::lower(db, expander, params, body)
+        lower::lower(db, def, expander, params, body)
    }
 }
@@ -213,6 +229,11 @@ impl BodySourceMap {
        self.expr_map.get(&src).cloned()
    }
+    pub fn field_init_shorthand_expr(&self, node: InFile<&ast::RecordField>) -> Option<ExprId> {
+        let src = node.map(|it| Either::Right(AstPtr::new(it)));
+        self.expr_map.get(&src).cloned()
+    }
    pub fn pat_syntax(&self, pat: PatId) -> Option<PatSource> {
        self.pat_map_back.get(pat).copied()
    }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 61193b4d8..853e17bae 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -2,11 +2,12 @@
 //! representation.
 use either::Either;
 use hir_expand::name::{name, AsName, Name};
 use ra_arena::Arena;
 use ra_syntax::{
    ast::{
-        self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner,
+        self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, ModuleItemOwner, NameOwner,
        TypeAscriptionOwner,
    },
    AstNode, AstPtr,
@@ -24,23 +25,28 @@ use crate::{
    path::GenericArgs,
    path::Path,
    type_ref::{Mutability, TypeRef},
+    ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId, StaticLoc,
+    StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
 pub(super) fn lower(
    db: &impl DefDatabase,
+    def: DefWithBodyId,
    expander: Expander,
    params: Option<ast::ParamList>,
    body: Option<ast::Expr>,
 ) -> (Body, BodySourceMap) {
    ExprCollector {
-        expander,
        db,
+        def,
+        expander,
        source_map: BodySourceMap::default(),
        body: Body {
            exprs: Arena::default(),
            pats: Arena::default(),
            params: Vec::new(),
            body_expr: ExprId::dummy(),
+            defs: Vec::new(),
        },
    }
    .collect(params, body)
@@ -48,6 +54,7 @@ pub(super) fn lower(
 struct ExprCollector<DB> {
    db: DB,
+    def: DefWithBodyId,
    expander: Expander,
    body: Body,
@@ -466,6 +473,7 @@ where
            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 {
@@ -482,6 +490,51 @@ where
        self.alloc_expr(Expr::Block { statements, tail }, syntax_node_ptr)
    }
+    fn collect_block_items(&mut self, block: &ast::Block) {
+        let container = ContainerId::DefWithBodyId(self.def);
+        for item in block.items() {
+            let def: ModuleDefId = match item {
+                ast::ModuleItem::FnDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    FunctionLoc { container: container.into(), ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::TypeAliasDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    TypeAliasLoc { container: container.into(), ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::ConstDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    ConstLoc { container: container.into(), ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::StaticDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    StaticLoc { container, ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::StructDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    StructLoc { container, ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::EnumDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    EnumLoc { container, ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::UnionDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    UnionLoc { container, ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::TraitDef(def) => {
+                    let ast_id = self.expander.ast_id(&def);
+                    TraitLoc { container, ast_id }.intern(self.db).into()
+                }
+                ast::ModuleItem::ImplBlock(_)
+                | ast::ModuleItem::UseItem(_)
+                | ast::ModuleItem::ExternCrateItem(_)
+                | ast::ModuleItem::Module(_) => continue,
+            };
+            self.body.defs.push(def)
+        }
+    }
    fn collect_block_opt(&mut self, expr: Option<ast::BlockExpr>) -> ExprId {
        if let Some(block) = expr {
            self.collect_block(block)
diff --git a/crates/ra_hir_def/src/child_by_source.rs b/crates/ra_hir_def/src/child_by_source.rs
index 3c9379b15..f5a65ad40 100644
--- a/crates/ra_hir_def/src/child_by_source.rs
+++ b/crates/ra_hir_def/src/child_by_source.rs
@@ -11,8 +11,8 @@ use crate::{
    dyn_map::DynMap,
    keys,
    src::{HasChildSource, HasSource},
-    AdtId, AssocItemId, EnumId, EnumVariantId, ImplId, Lookup, ModuleDefId, ModuleId,
+    AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, ImplId, Lookup, ModuleDefId,
-    StructFieldId, TraitId, VariantId,
+    ModuleId, StructFieldId, TraitId, VariantId,
 };
 pub trait ChildBySource {
@@ -76,47 +76,11 @@ impl ChildBySource for ModuleId {
        let mut res = DynMap::default();
        let crate_def_map = db.crate_def_map(self.krate);
-        for item in crate_def_map[self.local_id].scope.declarations() {
+        let module_data = &crate_def_map[self.local_id];
-            match item {
-                ModuleDefId::FunctionId(func) => {
-                    let src = func.lookup(db).source(db);
-                    res[keys::FUNCTION].insert(src, func)
-                }
-                ModuleDefId::ConstId(konst) => {
-                    let src = konst.lookup(db).source(db);
-                    res[keys::CONST].insert(src, konst)
-                }
-                ModuleDefId::StaticId(statik) => {
-                    let src = statik.lookup(db).source(db);
-                    res[keys::STATIC].insert(src, statik)
-                }
-                ModuleDefId::TypeAliasId(ty) => {
-                    let src = ty.lookup(db).source(db);
-                    res[keys::TYPE_ALIAS].insert(src, ty)
-                }
-                ModuleDefId::TraitId(trait_) => {
-                    let src = trait_.lookup(db).source(db);
-                    res[keys::TRAIT].insert(src, trait_)
-                }
-                ModuleDefId::AdtId(adt) => match adt {
-                    AdtId::StructId(strukt) => {
-                        let src = strukt.lookup(db).source(db);
-                        res[keys::STRUCT].insert(src, strukt)
-                    }
-                    AdtId::UnionId(union_) => {
-                        let src = union_.lookup(db).source(db);
-                        res[keys::UNION].insert(src, union_)
-                    }
-                    AdtId::EnumId(enum_) => {
-                        let src = enum_.lookup(db).source(db);
-                        res[keys::ENUM].insert(src, enum_)
-                    }
-                },
-                _ => (),
-            }
-        }
-        for &impl_ in crate_def_map[self.local_id].impls.iter() {
+        module_data.scope.declarations().for_each(|item| add_module_def(db, &mut res, item));
+        for &impl_ in module_data.impls.iter() {
            let src = impl_.lookup(db).source(db);
            res[keys::IMPL].insert(src, impl_)
        }
@@ -125,6 +89,46 @@ impl ChildBySource for ModuleId {
    }
 }
+fn add_module_def(db: &impl DefDatabase, map: &mut DynMap, item: ModuleDefId) {
+    match item {
+        ModuleDefId::FunctionId(func) => {
+            let src = func.lookup(db).source(db);
+            map[keys::FUNCTION].insert(src, func)
+        }
+        ModuleDefId::ConstId(konst) => {
+            let src = konst.lookup(db).source(db);
+            map[keys::CONST].insert(src, konst)
+        }
+        ModuleDefId::StaticId(statik) => {
+            let src = statik.lookup(db).source(db);
+            map[keys::STATIC].insert(src, statik)
+        }
+        ModuleDefId::TypeAliasId(ty) => {
+            let src = ty.lookup(db).source(db);
+            map[keys::TYPE_ALIAS].insert(src, ty)
+        }
+        ModuleDefId::TraitId(trait_) => {
+            let src = trait_.lookup(db).source(db);
+            map[keys::TRAIT].insert(src, trait_)
+        }
+        ModuleDefId::AdtId(adt) => match adt {
+            AdtId::StructId(strukt) => {
+                let src = strukt.lookup(db).source(db);
+                map[keys::STRUCT].insert(src, strukt)
+            }
+            AdtId::UnionId(union_) => {
+                let src = union_.lookup(db).source(db);
+                map[keys::UNION].insert(src, union_)
+            }
+            AdtId::EnumId(enum_) => {
+                let src = enum_.lookup(db).source(db);
+                map[keys::ENUM].insert(src, enum_)
+            }
+        },
+        _ => (),
+    }
+}
 impl ChildBySource for VariantId {
    fn child_by_source(&self, db: &impl DefDatabase) -> DynMap {
        let mut res = DynMap::default();
@@ -160,3 +164,12 @@ impl ChildBySource for EnumId {
        res
    }
 }
+impl ChildBySource for DefWithBodyId {
+    fn child_by_source(&self, db: &impl DefDatabase) -> DynMap {
+        let mut res = DynMap::default();
+        let body = db.body(*self);
+        body.defs.iter().copied().for_each(|item| add_module_def(db, &mut res, item));
+        res
+    }
+}
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 4f4ef57cc..14e86936b 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -12,8 +12,8 @@ use crate::{
    db::DefDatabase,
    src::HasSource,
    type_ref::{Mutability, TypeRef},
-    AssocItemId, ConstId, ConstLoc, ContainerId, FunctionId, FunctionLoc, ImplId, Intern, Lookup,
+    AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, ImplId, Intern,
-    StaticId, TraitId, TypeAliasId, TypeAliasLoc,
+    Lookup, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
 };
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -99,7 +99,7 @@ impl TraitData {
        let auto = src.value.is_auto();
        let ast_id_map = db.ast_id_map(src.file_id);
-        let container = ContainerId::TraitId(tr);
+        let container = AssocContainerId::TraitId(tr);
        let items = if let Some(item_list) = src.value.item_list() {
            item_list
                .impl_items()
@@ -180,7 +180,7 @@ impl ImplData {
                .map(|item_node| match item_node {
                    ast::ImplItem::FnDef(it) => {
                        let def = FunctionLoc {
-                            container: ContainerId::ImplId(id),
+                            container: AssocContainerId::ImplId(id),
                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
                        }
                        .intern(db);
@@ -188,7 +188,7 @@ impl ImplData {
                    }
                    ast::ImplItem::ConstDef(it) => {
                        let def = ConstLoc {
-                            container: ContainerId::ImplId(id),
+                            container: AssocContainerId::ImplId(id),
                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
                        }
                        .intern(db);
@@ -196,7 +196,7 @@ impl ImplData {
                    }
                    ast::ImplItem::TypeAliasDef(it) => {
                        let def = TypeAliasLoc {
-                            container: ContainerId::ImplId(id),
+                            container: AssocContainerId::ImplId(id),
                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
                        }
                        .intern(db);
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index f085bbe87..8ed1599ff 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -45,7 +45,7 @@ use std::hash::Hash;
 use hir_expand::{ast_id_map::FileAstId, AstId, HirFileId, InFile, MacroDefId};
 use ra_arena::{impl_arena_id, RawId};
 use ra_db::{impl_intern_key, salsa, CrateId};
-use ra_syntax::ast;
+use ra_syntax::{ast, AstNode};
 use crate::builtin_type::BuiltinType;
@@ -65,101 +65,57 @@ pub struct ModuleId {
 pub struct LocalModuleId(RawId);
 impl_arena_id!(LocalModuleId);
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct FunctionId(salsa::InternId);
-impl_intern_key!(FunctionId);
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct FunctionLoc {
+pub struct ItemLoc<N: AstNode> {
    pub container: ContainerId,
-    pub ast_id: AstId<ast::FnDef>,
+    pub ast_id: AstId<N>,
 }
-impl Intern for FunctionLoc {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-    type ID = FunctionId;
+pub struct AssocItemLoc<N: AstNode> {
-    fn intern(self, db: &impl db::DefDatabase) -> FunctionId {
+    pub container: AssocContainerId,
-        db.intern_function(self)
+    pub ast_id: AstId<N>,
-    }
 }
-impl Lookup for FunctionId {
+macro_rules! impl_intern {
-    type Data = FunctionLoc;
+    ($id:ident, $loc:ident, $intern:ident, $lookup:ident) => {
-    fn lookup(&self, db: &impl db::DefDatabase) -> FunctionLoc {
+        impl_intern_key!($id);
-        db.lookup_intern_function(*self)
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+        impl Intern for $loc {
-pub struct StructId(salsa::InternId);
+            type ID = $id;
-impl_intern_key!(StructId);
+            fn intern(self, db: &impl db::DefDatabase) -> $id {
+                db.$intern(self)
+            }
+        }
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+        impl Lookup for $id {
-pub struct StructLoc {
+            type Data = $loc;
-    pub container: ModuleId,
+            fn lookup(&self, db: &impl db::DefDatabase) -> $loc {
-    pub ast_id: AstId<ast::StructDef>,
+                db.$lookup(*self)
+            }
+        }
+    };
 }
-impl Intern for StructLoc {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-    type ID = StructId;
+pub struct FunctionId(salsa::InternId);
-    fn intern(self, db: &impl db::DefDatabase) -> StructId {
+type FunctionLoc = AssocItemLoc<ast::FnDef>;
-        db.intern_struct(self)
+impl_intern!(FunctionId, FunctionLoc, intern_function, lookup_intern_function);
-    }
-}
-impl Lookup for StructId {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-    type Data = StructLoc;
+pub struct StructId(salsa::InternId);
-    fn lookup(&self, db: &impl db::DefDatabase) -> StructLoc {
+type StructLoc = ItemLoc<ast::StructDef>;
-        db.lookup_intern_struct(*self)
+impl_intern!(StructId, StructLoc, intern_struct, lookup_intern_struct);
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct UnionId(salsa::InternId);
-impl_intern_key!(UnionId);
+pub type UnionLoc = ItemLoc<ast::UnionDef>;
+impl_intern!(UnionId, UnionLoc, intern_union, lookup_intern_union);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UnionLoc {
-    pub container: ModuleId,
-    pub ast_id: AstId<ast::UnionDef>,
-}
-impl Intern for UnionLoc {
-    type ID = UnionId;
-    fn intern(self, db: &impl db::DefDatabase) -> UnionId {
-        db.intern_union(self)
-    }
-}
-impl Lookup for UnionId {
-    type Data = UnionLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> UnionLoc {
-        db.lookup_intern_union(*self)
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct EnumId(salsa::InternId);
-impl_intern_key!(EnumId);
+pub type EnumLoc = ItemLoc<ast::EnumDef>;
+impl_intern!(EnumId, EnumLoc, intern_enum, lookup_intern_enum);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct EnumLoc {
-    pub container: ModuleId,
-    pub ast_id: AstId<ast::EnumDef>,
-}
-impl Intern for EnumLoc {
-    type ID = EnumId;
-    fn intern(self, db: &impl db::DefDatabase) -> EnumId {
-        db.intern_enum(self)
-    }
-}
-impl Lookup for EnumId {
-    type Data = EnumLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> EnumLoc {
-        db.lookup_intern_enum(*self)
-    }
-}
 // FIXME: rename to `VariantId`, only enums can ave variants
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -184,122 +140,38 @@ impl_arena_id!(LocalStructFieldId);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ConstId(salsa::InternId);
-impl_intern_key!(ConstId);
+type ConstLoc = AssocItemLoc<ast::ConstDef>;
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+impl_intern!(ConstId, ConstLoc, intern_const, lookup_intern_const);
-pub struct ConstLoc {
-    pub container: ContainerId,
-    pub ast_id: AstId<ast::ConstDef>,
-}
-impl Intern for ConstLoc {
-    type ID = ConstId;
-    fn intern(self, db: &impl db::DefDatabase) -> ConstId {
-        db.intern_const(self)
-    }
-}
-impl Lookup for ConstId {
-    type Data = ConstLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> ConstLoc {
-        db.lookup_intern_const(*self)
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct StaticId(salsa::InternId);
-impl_intern_key!(StaticId);
+pub type StaticLoc = ItemLoc<ast::StaticDef>;
+impl_intern!(StaticId, StaticLoc, intern_static, lookup_intern_static);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct StaticLoc {
-    pub container: ModuleId,
-    pub ast_id: AstId<ast::StaticDef>,
-}
-impl Intern for StaticLoc {
-    type ID = StaticId;
-    fn intern(self, db: &impl db::DefDatabase) -> StaticId {
-        db.intern_static(self)
-    }
-}
-impl Lookup for StaticId {
-    type Data = StaticLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> StaticLoc {
-        db.lookup_intern_static(*self)
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct TraitId(salsa::InternId);
-impl_intern_key!(TraitId);
+pub type TraitLoc = ItemLoc<ast::TraitDef>;
+impl_intern!(TraitId, TraitLoc, intern_trait, lookup_intern_trait);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TraitLoc {
-    pub container: ModuleId,
-    pub ast_id: AstId<ast::TraitDef>,
-}
-impl Intern for TraitLoc {
-    type ID = TraitId;
-    fn intern(self, db: &impl db::DefDatabase) -> TraitId {
-        db.intern_trait(self)
-    }
-}
-impl Lookup for TraitId {
-    type Data = TraitLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> TraitLoc {
-        db.lookup_intern_trait(*self)
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct TypeAliasId(salsa::InternId);
-impl_intern_key!(TypeAliasId);
+type TypeAliasLoc = AssocItemLoc<ast::TypeAliasDef>;
+impl_intern!(TypeAliasId, TypeAliasLoc, intern_type_alias, lookup_intern_type_alias);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeAliasLoc {
-    pub container: ContainerId,
-    pub ast_id: AstId<ast::TypeAliasDef>,
-}
-impl Intern for TypeAliasLoc {
-    type ID = TypeAliasId;
-    fn intern(self, db: &impl db::DefDatabase) -> TypeAliasId {
-        db.intern_type_alias(self)
-    }
-}
-impl Lookup for TypeAliasId {
-    type Data = TypeAliasLoc;
-    fn lookup(&self, db: &impl db::DefDatabase) -> TypeAliasLoc {
-        db.lookup_intern_type_alias(*self)
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ImplId(salsa::InternId);
-impl_intern_key!(ImplId);
+type ImplLoc = ItemLoc<ast::ImplBlock>;
+impl_intern!(ImplId, ImplLoc, intern_impl, lookup_intern_impl);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ImplLoc {
-    pub container: ModuleId,
-    pub ast_id: AstId<ast::ImplBlock>,
-}
-impl Intern for ImplLoc {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-    type ID = ImplId;
+pub struct TypeParamId {
-    fn intern(self, db: &impl db::DefDatabase) -> ImplId {
+    pub parent: GenericDefId,
-        db.intern_impl(self)
+    pub local_id: LocalTypeParamId,
-    }
 }
-impl Lookup for ImplId {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-    type Data = ImplLoc;
+pub struct LocalTypeParamId(RawId);
-    fn lookup(&self, db: &impl db::DefDatabase) -> ImplLoc {
+impl_arena_id!(LocalTypeParamId);
-        db.lookup_intern_impl(*self)
-    }
-}
 macro_rules! impl_froms {
    ($e:ident: $($v:ident $(($($sv:ident),*))?),*) => {
@@ -321,21 +193,18 @@ macro_rules! impl_froms {
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct TypeParamId {
+pub enum ContainerId {
-    pub parent: GenericDefId,
+    ModuleId(ModuleId),
-    pub local_id: LocalTypeParamId,
+    DefWithBodyId(DefWithBodyId),
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct LocalTypeParamId(RawId);
+pub enum AssocContainerId {
-impl_arena_id!(LocalTypeParamId);
+    ContainerId(ContainerId),
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum ContainerId {
-    ModuleId(ModuleId),
    ImplId(ImplId),
    TraitId(TraitId),
 }
+impl_froms!(AssocContainerId: ContainerId);
 /// A Data Type
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -478,33 +347,28 @@ pub trait HasModule {
    fn module(&self, db: &impl db::DefDatabase) -> ModuleId;
 }
-impl HasModule for FunctionLoc {
+impl HasModule for ContainerId {
    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
-        match self.container {
+        match *self {
            ContainerId::ModuleId(it) => it,
-            ContainerId::ImplId(it) => it.lookup(db).container,
+            ContainerId::DefWithBodyId(it) => it.module(db),
-            ContainerId::TraitId(it) => it.lookup(db).container,
        }
    }
 }
-impl HasModule for TypeAliasLoc {
+impl HasModule for AssocContainerId {
    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
-        match self.container {
+        match *self {
-            ContainerId::ModuleId(it) => it,
+            AssocContainerId::ContainerId(it) => it.module(db),
-            ContainerId::ImplId(it) => it.lookup(db).container,
+            AssocContainerId::ImplId(it) => it.lookup(db).container.module(db),
-            ContainerId::TraitId(it) => it.lookup(db).container,
+            AssocContainerId::TraitId(it) => it.lookup(db).container.module(db),
        }
    }
 }
-impl HasModule for ConstLoc {
+impl<N: AstNode> HasModule for AssocItemLoc<N> {
    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
-        match self.container {
+        self.container.module(db)
-            ContainerId::ModuleId(it) => it,
-            ContainerId::ImplId(it) => it.lookup(db).container,
-            ContainerId::TraitId(it) => it.lookup(db).container,
-        }
    }
 }
@@ -515,6 +379,7 @@ impl HasModule for AdtId {
            AdtId::UnionId(it) => it.lookup(db).container,
            AdtId::EnumId(it) => it.lookup(db).container,
        }
+        .module(db)
    }
 }
@@ -533,17 +398,17 @@ impl HasModule for GenericDefId {
        match self {
            GenericDefId::FunctionId(it) => it.lookup(db).module(db),
            GenericDefId::AdtId(it) => it.module(db),
-            GenericDefId::TraitId(it) => it.lookup(db).container,
+            GenericDefId::TraitId(it) => it.lookup(db).container.module(db),
            GenericDefId::TypeAliasId(it) => it.lookup(db).module(db),
-            GenericDefId::ImplId(it) => it.lookup(db).container,
+            GenericDefId::ImplId(it) => it.lookup(db).container.module(db),
-            GenericDefId::EnumVariantId(it) => it.parent.lookup(db).container,
+            GenericDefId::EnumVariantId(it) => it.parent.lookup(db).container.module(db),
            GenericDefId::ConstId(it) => it.lookup(db).module(db),
        }
    }
 }
 impl HasModule for StaticLoc {
-    fn module(&self, _db: &impl db::DefDatabase) -> ModuleId {
+    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
-        self.container
+        self.container.module(db)
    }
 }
diff --git a/crates/ra_hir_def/src/marks.rs b/crates/ra_hir_def/src/marks.rs
index 65239ca0a..457ba4abe 100644
--- a/crates/ra_hir_def/src/marks.rs
+++ b/crates/ra_hir_def/src/marks.rs
@@ -5,6 +5,7 @@ test_utils::marks!(
    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
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 9aae7e48e..af52fa36e 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -57,9 +57,7 @@ mod tests;
 use std::sync::Arc;
-use hir_expand::{
+use hir_expand::{diagnostics::DiagnosticSink, name::Name, InFile, MacroDefId};
-    ast_id_map::FileAstId, diagnostics::DiagnosticSink, name::Name, InFile, MacroDefId,
-};
 use once_cell::sync::Lazy;
 use ra_arena::Arena;
 use ra_db::{CrateId, Edition, FileId, FilePosition};
@@ -76,7 +74,7 @@ use crate::{
    nameres::{diagnostics::DefDiagnostic, path_resolution::ResolveMode},
    path::ModPath,
    per_ns::PerNs,
-    AstId, FunctionId, ImplId, LocalImportId, LocalModuleId, ModuleDefId, ModuleId, TraitId,
+    AstId, ImplId, LocalImportId, LocalModuleId, ModuleDefId, ModuleId, TraitId,
 };
 /// Contains all top-level defs from a macro-expanded crate
@@ -176,11 +174,6 @@ pub struct ModuleData {
    pub impls: Vec<ImplId>,
 }
-#[derive(Default, Debug, PartialEq, Eq)]
-pub(crate) struct Declarations {
-    fns: FxHashMap<FileAstId<ast::FnDef>, FunctionId>,
-}
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ModuleScope {
    items: FxHashMap<Name, Resolution>,
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 8bbf7ffa2..e68bf4868 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -661,9 +661,10 @@ where
                            krate: self.def_collector.def_map.krate,
                            local_id: self.module_id,
                        };
+                        let container = ContainerId::ModuleId(module);
                        let ast_id = self.raw_items[imp].ast_id;
                        let impl_id =
-                            ImplLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                            ImplLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                                .intern(self.def_collector.db);
                        self.def_collector.def_map.modules[self.module_id].impls.push(impl_id)
                    }
@@ -760,10 +761,11 @@ where
        self.collect_derives(attrs, def);
        let name = def.name.clone();
+        let container = ContainerId::ModuleId(module);
        let def: PerNs = match def.kind {
            raw::DefKind::Function(ast_id) => {
                let def = FunctionLoc {
-                    container: ContainerId::ModuleId(module),
+                    container: container.into(),
                    ast_id: AstId::new(self.file_id, ast_id),
                }
                .intern(self.def_collector.db);
@@ -771,23 +773,23 @@ where
                PerNs::values(def.into())
            }
            raw::DefKind::Struct(ast_id) => {
-                let def = StructLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                let def = StructLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                    .intern(self.def_collector.db);
                PerNs::both(def.into(), def.into())
            }
            raw::DefKind::Union(ast_id) => {
-                let def = UnionLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                let def = UnionLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                    .intern(self.def_collector.db);
                PerNs::both(def.into(), def.into())
            }
            raw::DefKind::Enum(ast_id) => {
-                let def = EnumLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                let def = EnumLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                    .intern(self.def_collector.db);
                PerNs::types(def.into())
            }
            raw::DefKind::Const(ast_id) => {
                let def = ConstLoc {
-                    container: ContainerId::ModuleId(module),
+                    container: container.into(),
                    ast_id: AstId::new(self.file_id, ast_id),
                }
                .intern(self.def_collector.db);
@@ -795,20 +797,20 @@ where
                PerNs::values(def.into())
            }
            raw::DefKind::Static(ast_id) => {
-                let def = StaticLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                let def = StaticLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                    .intern(self.def_collector.db);
                PerNs::values(def.into())
            }
            raw::DefKind::Trait(ast_id) => {
-                let def = TraitLoc { container: module, ast_id: AstId::new(self.file_id, ast_id) }
+                let def = TraitLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
                    .intern(self.def_collector.db);
                PerNs::types(def.into())
            }
            raw::DefKind::TypeAlias(ast_id) => {
                let def = TypeAliasLoc {
-                    container: ContainerId::ModuleId(module),
+                    container: container.into(),
                    ast_id: AstId::new(self.file_id, ast_id),
                }
                .intern(self.def_collector.db);
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index 1dbc4f371..2dd779b66 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -145,11 +145,6 @@ impl CrateDefMap {
                    return ResolvePathResult::empty(ReachedFixedPoint::No); // extern crate declarations can add to the extern prelude
                }
            }
-            PathKind::Type(_) => {
-                // This is handled in `infer::infer_path_expr`
-                // The result returned here does not matter
-                return ResolvePathResult::empty(ReachedFixedPoint::Yes);
-            }
        };
        for (i, segment) in segments {
diff --git a/crates/ra_hir_def/src/nameres/tests/globs.rs b/crates/ra_hir_def/src/nameres/tests/globs.rs
index 5b03fe365..5e24cb94d 100644
--- a/crates/ra_hir_def/src/nameres/tests/globs.rs
+++ b/crates/ra_hir_def/src/nameres/tests/globs.rs
@@ -112,3 +112,24 @@ fn glob_enum() {
    "###
    );
 }
+#[test]
+fn glob_enum_group() {
+    covers!(glob_enum_group);
+    let map = def_map(
+        "
+        //- /lib.rs
+        enum Foo {
+            Bar, Baz
+        }
+        use self::Foo::{*};
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Bar: t v
+   ⋮Baz: t v
+   ⋮Foo: t
+    "###
+    );
+}
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 9e37ac416..00325cd99 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -18,6 +18,18 @@ pub struct ModPath {
    pub segments: Vec<Name>,
 }
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum PathKind {
+    Plain,
+    /// `self::` is `Super(0)`
+    Super(u8),
+    Crate,
+    /// Absolute path (::foo)
+    Abs,
+    /// `$crate` from macro expansion
+    DollarCrate(CrateId),
+}
 impl ModPath {
    pub fn from_src(path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
        lower::lower_path(path, hygiene).map(|it| it.mod_path)
@@ -70,6 +82,9 @@ impl ModPath {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Path {
+    /// Type based path like `<T>::foo`.
+    /// Note that paths like `<Type as Trait>::foo` are desugard to `Trait::<Self=Type>::foo`.
+    type_anchor: Option<Box<TypeRef>>,
    mod_path: ModPath,
    /// Invariant: the same len as self.path.segments
    generic_args: Vec<Option<Arc<GenericArgs>>>,
@@ -97,19 +112,6 @@ pub enum GenericArg {
    // or lifetime...
 }
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum PathKind {
-    Plain,
-    Super(u8),
-    Crate,
-    // Absolute path
-    Abs,
-    // Type based path like `<T>::foo`
-    Type(Box<TypeRef>),
-    // `$crate` from macro expansion
-    DollarCrate(CrateId),
-}
 impl Path {
    /// Converts an `ast::Path` to `Path`. Works with use trees.
    /// DEPRECATED: It does not handle `$crate` from macro call.
@@ -125,18 +127,17 @@ impl Path {
    /// Converts an `ast::NameRef` into a single-identifier `Path`.
    pub(crate) fn from_name_ref(name_ref: &ast::NameRef) -> Path {
-        Path { mod_path: name_ref.as_name().into(), generic_args: vec![None] }
+        Path { type_anchor: None, mod_path: name_ref.as_name().into(), generic_args: vec![None] }
-    }
-    /// `true` if this path is just a standalone `self`
-    pub fn is_self(&self) -> bool {
-        self.mod_path.is_self()
    }
    pub fn kind(&self) -> &PathKind {
        &self.mod_path.kind
    }
+    pub fn type_anchor(&self) -> Option<&TypeRef> {
+        self.type_anchor.as_ref().map(|it| &**it)
+    }
    pub fn segments(&self) -> PathSegments<'_> {
        PathSegments {
            segments: self.mod_path.segments.as_slice(),
@@ -153,6 +154,7 @@ impl Path {
            return None;
        }
        let res = Path {
+            type_anchor: self.type_anchor.clone(),
            mod_path: ModPath {
                kind: self.mod_path.kind.clone(),
                segments: self.mod_path.segments[..self.mod_path.segments.len() - 1].to_vec(),
@@ -225,6 +227,7 @@ impl GenericArgs {
 impl From<Name> for Path {
    fn from(name: Name) -> Path {
        Path {
+            type_anchor: None,
            mod_path: ModPath::from_simple_segments(PathKind::Plain, iter::once(name)),
            generic_args: vec![None],
        }
diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs
index c71b52d89..62aafd508 100644
--- a/crates/ra_hir_def/src/path/lower.rs
+++ b/crates/ra_hir_def/src/path/lower.rs
@@ -22,6 +22,7 @@ pub(super) use lower_use::lower_use_tree;
 /// It correctly handles `$crate` based path from macro call.
 pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
    let mut kind = PathKind::Plain;
+    let mut type_anchor = None;
    let mut segments = Vec::new();
    let mut generic_args = Vec::new();
    loop {
@@ -63,7 +64,8 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
                match trait_ref {
                    // <T>::foo
                    None => {
-                        kind = PathKind::Type(Box::new(self_type));
+                        type_anchor = Some(Box::new(self_type));
+                        kind = PathKind::Plain;
                    }
                    // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
                    Some(trait_ref) => {
@@ -111,7 +113,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
    segments.reverse();
    generic_args.reverse();
    let mod_path = ModPath { kind, segments };
-    return Some(Path { mod_path, generic_args });
+    return Some(Path { type_anchor, mod_path, generic_args });
    fn qualifier(path: &ast::Path) -> Option<ast::Path> {
        if let Some(q) = path.qualifier() {
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 062c02063..3218eaf0a 100644
--- a/crates/ra_hir_def/src/path/lower/lower_use.rs
+++ b/crates/ra_hir_def/src/path/lower/lower_use.rs
@@ -9,6 +9,7 @@ use hir_expand::{
    name::{AsName, Name},
 };
 use ra_syntax::ast::{self, NameOwner};
+use test_utils::tested_by;
 use crate::path::{ModPath, PathKind};
@@ -34,6 +35,7 @@ pub(crate) fn lower_use_tree(
        }
    } else {
        let alias = tree.alias().and_then(|a| a.name()).map(|a| a.as_name());
+        let is_glob = tree.has_star();
        if let Some(ast_path) = tree.path() {
            // Handle self in a path.
            // E.g. `use something::{self, <...>}`
@@ -48,11 +50,15 @@ pub(crate) fn lower_use_tree(
                }
            }
            if let Some(path) = convert_path(prefix, ast_path, hygiene) {
-                let is_glob = tree.has_star();
                cb(path, &tree, is_glob, alias)
            }
-            // FIXME: report errors somewhere
+        // FIXME: report errors somewhere
-            // We get here if we do
+        // We get here if we do
+        } else if is_glob {
+            tested_by!(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 2694c0438..af9d194f8 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -17,9 +17,9 @@ use crate::{
    nameres::{BuiltinShadowMode, CrateDefMap},
    path::{ModPath, PathKind},
    per_ns::PerNs,
-    AdtId, ConstId, ContainerId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId,
+    AdtId, AssocContainerId, ConstId, ContainerId, DefWithBodyId, EnumId, EnumVariantId,
-    HasModule, ImplId, LocalModuleId, Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId,
+    FunctionId, GenericDefId, HasModule, ImplId, LocalModuleId, Lookup, ModuleDefId, ModuleId,
-    TypeAliasId, TypeParamId, VariantId,
+    StaticId, StructId, TraitId, TypeAliasId, TypeParamId, VariantId,
 };
 #[derive(Debug, Clone, Default)]
@@ -583,9 +583,18 @@ impl HasResolver for DefWithBodyId {
 impl HasResolver for ContainerId {
    fn resolver(self, db: &impl DefDatabase) -> Resolver {
        match self {
-            ContainerId::TraitId(it) => it.resolver(db),
-            ContainerId::ImplId(it) => it.resolver(db),
            ContainerId::ModuleId(it) => it.resolver(db),
+            ContainerId::DefWithBodyId(it) => it.resolver(db),
+        }
+    }
+}
+impl HasResolver for AssocContainerId {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
+        match self {
+            AssocContainerId::ContainerId(it) => it.resolver(db),
+            AssocContainerId::TraitId(it) => it.resolver(db),
+            AssocContainerId::ImplId(it) => it.resolver(db),
        }
    }
 }
diff --git a/crates/ra_hir_def/src/src.rs b/crates/ra_hir_def/src/src.rs
index 20200d1db..499375b80 100644
--- a/crates/ra_hir_def/src/src.rs
+++ b/crates/ra_hir_def/src/src.rs
@@ -2,94 +2,28 @@
 use hir_expand::InFile;
 use ra_arena::map::ArenaMap;
-use ra_syntax::ast;
+use ra_syntax::AstNode;
-use crate::{
+use crate::{db::DefDatabase, AssocItemLoc, ItemLoc};
-    db::DefDatabase, ConstLoc, EnumLoc, FunctionLoc, ImplLoc, StaticLoc, StructLoc, TraitLoc,
-    TypeAliasLoc, UnionLoc,
-};
 pub trait HasSource {
    type Value;
    fn source(&self, db: &impl DefDatabase) -> InFile<Self::Value>;
 }
-impl HasSource for FunctionLoc {
+impl<N: AstNode> HasSource for AssocItemLoc<N> {
-    type Value = ast::FnDef;
+    type Value = N;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::FnDef> {
+    fn source(&self, db: &impl DefDatabase) -> InFile<N> {
        let node = self.ast_id.to_node(db);
        InFile::new(self.ast_id.file_id, node)
    }
 }
-impl HasSource for TypeAliasLoc {
+impl<N: AstNode> HasSource for ItemLoc<N> {
-    type Value = ast::TypeAliasDef;
+    type Value = N;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::TypeAliasDef> {
+    fn source(&self, db: &impl DefDatabase) -> InFile<N> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for ConstLoc {
-    type Value = ast::ConstDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::ConstDef> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for StaticLoc {
-    type Value = ast::StaticDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::StaticDef> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for ImplLoc {
-    type Value = ast::ImplBlock;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::ImplBlock> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for TraitLoc {
-    type Value = ast::TraitDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::TraitDef> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for StructLoc {
-    type Value = ast::StructDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::StructDef> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for UnionLoc {
-    type Value = ast::UnionDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::UnionDef> {
-        let node = self.ast_id.to_node(db);
-        InFile::new(self.ast_id.file_id, node)
-    }
-}
-impl HasSource for EnumLoc {
-    type Value = ast::EnumDef;
-    fn source(&self, db: &impl DefDatabase) -> InFile<ast::EnumDef> {
        let node = self.ast_id.to_node(db);
        InFile::new(self.ast_id.file_id, node)
    }
diff --git a/crates/ra_hir_ty/src/display.rs b/crates/ra_hir_ty/src/display.rs
index 9bb3ece6c..dcca1bace 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -10,6 +10,7 @@ pub struct HirFormatter<'a, 'b, DB> {
    buf: String,
    curr_size: usize,
    max_size: Option<usize>,
+    should_display_default_types: bool,
 }
 pub trait HirDisplay {
@@ -19,7 +20,7 @@ pub trait HirDisplay {
    where
        Self: Sized,
    {
-        HirDisplayWrapper(db, self, None)
+        HirDisplayWrapper(db, self, None, true)
    }
    fn display_truncated<'a, DB>(
@@ -30,7 +31,7 @@ pub trait HirDisplay {
    where
        Self: Sized,
    {
-        HirDisplayWrapper(db, self, max_size)
+        HirDisplayWrapper(db, self, max_size, false)
    }
 }
@@ -72,9 +73,13 @@ where
            false
        }
    }
+    pub fn should_display_default_types(&self) -> bool {
+        self.should_display_default_types
+    }
 }
-pub struct HirDisplayWrapper<'a, DB, T>(&'a DB, &'a T, Option<usize>);
+pub struct HirDisplayWrapper<'a, DB, T>(&'a DB, &'a T, Option<usize>, bool);
 impl<'a, DB, T> fmt::Display for HirDisplayWrapper<'a, DB, T>
 where
@@ -88,6 +93,7 @@ where
            buf: String::with_capacity(20),
            curr_size: 0,
            max_size: self.2,
+            should_display_default_types: self.3,
        })
    }
 }
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 011c6c5c6..8be567917 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -8,7 +8,7 @@ use hir_def::{
    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
    path::{GenericArg, GenericArgs},
    resolver::resolver_for_expr,
-    AdtId, ContainerId, Lookup, StructFieldId,
+    AdtId, AssocContainerId, Lookup, StructFieldId,
 };
 use hir_expand::name::{name, Name};
 use ra_syntax::ast::RangeOp;
@@ -676,7 +676,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                // add obligation for trait implementation, if this is a trait method
                match def {
                    CallableDef::FunctionId(f) => {
-                        if let ContainerId::TraitId(trait_) = f.lookup(self.db).container {
+                        if let AssocContainerId::TraitId(trait_) = f.lookup(self.db).container {
                            // construct a TraitDef
                            let substs =
                                a_ty.parameters.prefix(generics(self.db, trait_.into()).len());
diff --git a/crates/ra_hir_ty/src/infer/path.rs b/crates/ra_hir_ty/src/infer/path.rs
index 3bae0ca6c..ffd358367 100644
--- a/crates/ra_hir_ty/src/infer/path.rs
+++ b/crates/ra_hir_ty/src/infer/path.rs
@@ -3,9 +3,9 @@
 use std::iter;
 use hir_def::{
-    path::{Path, PathKind, PathSegment},
+    path::{Path, PathSegment},
    resolver::{ResolveValueResult, Resolver, TypeNs, ValueNs},
-    AssocItemId, ContainerId, Lookup,
+    AssocContainerId, AssocItemId, Lookup,
 };
 use hir_expand::name::Name;
@@ -32,7 +32,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        path: &Path,
        id: ExprOrPatId,
    ) -> Option<Ty> {
-        let (value, self_subst) = if let PathKind::Type(type_ref) = path.kind() {
+        let (value, self_subst) = if let Some(type_ref) = path.type_anchor() {
            if path.segments().is_empty() {
                // This can't actually happen syntax-wise
                return None;
@@ -209,7 +209,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    AssocItemId::TypeAliasId(_) => unreachable!(),
                };
                let substs = match container {
-                    ContainerId::ImplId(impl_id) => {
+                    AssocContainerId::ImplId(impl_id) => {
                        let impl_substs = Substs::build_for_def(self.db, impl_id)
                            .fill(iter::repeat_with(|| self.table.new_type_var()))
                            .build();
@@ -221,7 +221,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                        self.unify(&impl_self_ty, &ty);
                        Some(substs)
                    }
-                    ContainerId::TraitId(trait_) => {
+                    AssocContainerId::TraitId(trait_) => {
                        // we're picking this method
                        let trait_substs = Substs::build_for_def(self.db, trait_)
                            .push(ty.clone())
@@ -237,7 +237,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                        }));
                        Some(substs)
                    }
-                    ContainerId::ModuleId(_) => None,
+                    AssocContainerId::ContainerId(_) => None,
                };
                self.write_assoc_resolution(id, item.into());
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 3ad913e55..7310ef10d 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -44,8 +44,8 @@ use std::sync::Arc;
 use std::{fmt, iter, mem};
 use hir_def::{
-    expr::ExprId, type_ref::Mutability, AdtId, ContainerId, DefWithBodyId, GenericDefId, HasModule,
+    expr::ExprId, type_ref::Mutability, AdtId, AssocContainerId, DefWithBodyId, GenericDefId,
-    Lookup, TraitId, TypeAliasId,
+    HasModule, Lookup, TraitId, TypeAliasId,
 };
 use hir_expand::name::Name;
 use ra_db::{impl_intern_key, salsa, CrateId};
@@ -251,7 +251,7 @@ impl ProjectionTy {
    fn trait_(&self, db: &impl HirDatabase) -> TraitId {
        match self.associated_ty.lookup(db).container {
-            ContainerId::TraitId(it) => it,
+            AssocContainerId::TraitId(it) => it,
            _ => panic!("projection ty without parent trait"),
        }
    }
@@ -906,13 +906,44 @@ impl HirDisplay for ApplicationTy {
                write!(f, "{}", name)?;
                if self.parameters.len() > 0 {
                    write!(f, "<")?;
-                    f.write_joined(&*self.parameters.0, ", ")?;
+                    let mut non_default_parameters = Vec::with_capacity(self.parameters.len());
+                    let parameters_to_write = if f.should_display_default_types() {
+                        self.parameters.0.as_ref()
+                    } else {
+                        match self
+                            .ctor
+                            .as_generic_def()
+                            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
+                            .filter(|defaults| !defaults.is_empty())
+                        {
+                            Option::None => self.parameters.0.as_ref(),
+                            Option::Some(default_parameters) => {
+                                for (i, parameter) in self.parameters.into_iter().enumerate() {
+                                    match (parameter, default_parameters.get(i)) {
+                                        (&Ty::Unknown, _) | (_, None) => {
+                                            non_default_parameters.push(parameter.clone())
+                                        }
+                                        (_, Some(default_parameter))
+                                            if parameter != default_parameter =>
+                                        {
+                                            non_default_parameters.push(parameter.clone())
+                                        }
+                                        _ => (),
+                                    }
+                                }
+                                &non_default_parameters
+                            }
+                        }
+                    };
+                    f.write_joined(parameters_to_write, ", ")?;
                    write!(f, ">")?;
                }
            }
            TypeCtor::AssociatedType(type_alias) => {
                let trait_ = match type_alias.lookup(f.db).container {
-                    ContainerId::TraitId(it) => it,
+                    AssocContainerId::TraitId(it) => it,
                    _ => panic!("not an associated type"),
                };
                let trait_name = f.db.trait_data(trait_).name.clone();
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index a4ddfc8ef..af3db2e1d 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -11,7 +11,7 @@ use std::sync::Arc;
 use hir_def::{
    builtin_type::BuiltinType,
    generics::WherePredicate,
-    path::{GenericArg, Path, PathKind, PathSegment, PathSegments},
+    path::{GenericArg, Path, PathSegment, PathSegments},
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{TypeBound, TypeRef},
    AdtId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, HasModule, ImplId,
@@ -101,7 +101,7 @@ impl Ty {
            TypeRef::Path(path) => path,
            _ => return None,
        };
-        if let PathKind::Type(_) = path.kind() {
+        if path.type_anchor().is_some() {
            return None;
        }
        if path.segments().len() > 1 {
@@ -202,7 +202,7 @@ impl Ty {
    pub(crate) fn from_hir_path(db: &impl HirDatabase, resolver: &Resolver, path: &Path) -> Ty {
        // Resolve the path (in type namespace)
-        if let PathKind::Type(type_ref) = path.kind() {
+        if let Some(type_ref) = path.type_anchor() {
            let ty = Ty::from_hir(db, resolver, &type_ref);
            return Ty::from_type_relative_path(db, resolver, ty, path.segments());
        }
@@ -697,8 +697,8 @@ impl CallableDef {
    pub fn krate(self, db: &impl HirDatabase) -> CrateId {
        match self {
            CallableDef::FunctionId(f) => f.lookup(db).module(db),
-            CallableDef::StructId(s) => s.lookup(db).container,
+            CallableDef::StructId(s) => s.lookup(db).container.module(db),
-            CallableDef::EnumVariantId(e) => e.parent.lookup(db).container,
+            CallableDef::EnumVariantId(e) => e.parent.lookup(db).container.module(db),
        }
        .krate
    }
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index 848e306e9..92fb4c081 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -6,8 +6,8 @@ use std::sync::Arc;
 use arrayvec::ArrayVec;
 use hir_def::{
-    lang_item::LangItemTarget, resolver::Resolver, type_ref::Mutability, AssocItemId, FunctionId,
+    lang_item::LangItemTarget, resolver::Resolver, type_ref::Mutability, AssocContainerId,
-    HasModule, ImplId, Lookup, TraitId,
+    AssocItemId, FunctionId, HasModule, ImplId, Lookup, TraitId,
 };
 use hir_expand::name::Name;
 use ra_db::CrateId;
@@ -134,7 +134,7 @@ impl Ty {
                LangItemTarget::ImplBlockId(it) => Some(it),
                _ => None,
            })
-            .map(|it| it.lookup(db).container.krate)
+            .map(|it| it.lookup(db).container.module(db).krate)
            .collect();
        Some(res)
    }
@@ -451,12 +451,12 @@ fn transform_receiver_ty(
    self_ty: &Canonical<Ty>,
 ) -> Option<Ty> {
    let substs = match function_id.lookup(db).container {
-        hir_def::ContainerId::TraitId(_) => Substs::build_for_def(db, function_id)
+        AssocContainerId::TraitId(_) => Substs::build_for_def(db, function_id)
            .push(self_ty.value.clone())
            .fill_with_unknown()
            .build(),
-        hir_def::ContainerId::ImplId(impl_id) => inherent_impl_substs(db, impl_id, &self_ty)?,
+        AssocContainerId::ImplId(impl_id) => inherent_impl_substs(db, impl_id, &self_ty)?,
-        hir_def::ContainerId::ModuleId(_) => unreachable!(),
+        AssocContainerId::ContainerId(_) => unreachable!(),
    };
    let sig = db.callable_item_signature(function_id.into());
    Some(sig.params()[0].clone().subst(&substs))
diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs
index fc21872b2..5eb032d86 100644
--- a/crates/ra_hir_ty/src/traits/chalk.rs
+++ b/crates/ra_hir_ty/src/traits/chalk.rs
@@ -9,7 +9,9 @@ use chalk_ir::{
 };
 use chalk_rust_ir::{AssociatedTyDatum, AssociatedTyValue, ImplDatum, StructDatum, TraitDatum};
-use hir_def::{AssocItemId, ContainerId, GenericDefId, ImplId, Lookup, TraitId, TypeAliasId};
+use hir_def::{
+    AssocContainerId, AssocItemId, GenericDefId, HasModule, ImplId, Lookup, TraitId, TypeAliasId,
+};
 use ra_db::{
    salsa::{InternId, InternKey},
    CrateId,
@@ -542,7 +544,7 @@ pub(crate) fn associated_ty_data_query(
    debug!("associated_ty_data {:?}", id);
    let type_alias: TypeAliasId = from_chalk(db, id);
    let trait_ = match type_alias.lookup(db).container {
-        ContainerId::TraitId(t) => t,
+        AssocContainerId::TraitId(t) => t,
        _ => panic!("associated type not in trait"),
    };
    let generic_params = generics(db, type_alias.into());
@@ -591,7 +593,7 @@ pub(crate) fn trait_datum_query(
    let bound_vars = Substs::bound_vars(&generic_params);
    let flags = chalk_rust_ir::TraitFlags {
        auto: trait_data.auto,
-        upstream: trait_.lookup(db).container.krate != krate,
+        upstream: trait_.lookup(db).container.module(db).krate != krate,
        non_enumerable: true,
        coinductive: false, // only relevant for Chalk testing
        // FIXME set these flags correctly
@@ -671,7 +673,7 @@ fn impl_block_datum(
    let bound_vars = Substs::bound_vars(&generic_params);
    let trait_ref = trait_ref.subst(&bound_vars);
    let trait_ = trait_ref.trait_;
-    let impl_type = if impl_id.lookup(db).container.krate == krate {
+    let impl_type = if impl_id.lookup(db).container.module(db).krate == krate {
        chalk_rust_ir::ImplType::Local
    } else {
        chalk_rust_ir::ImplType::External
@@ -755,7 +757,7 @@ fn type_alias_associated_ty_value(
 ) -> Arc<AssociatedTyValue<ChalkIr>> {
    let type_alias_data = db.type_alias_data(type_alias);
    let impl_id = match type_alias.lookup(db).container {
-        ContainerId::ImplId(it) => it,
+        AssocContainerId::ImplId(it) => it,
        _ => panic!("assoc ty value should be in impl"),
    };
diff --git a/crates/ra_hir_ty/src/utils.rs b/crates/ra_hir_ty/src/utils.rs
index 29799a8cb..0b1806a84 100644
--- a/crates/ra_hir_ty/src/utils.rs
+++ b/crates/ra_hir_ty/src/utils.rs
@@ -9,7 +9,7 @@ use hir_def::{
    path::Path,
    resolver::{HasResolver, TypeNs},
    type_ref::TypeRef,
-    ContainerId, GenericDefId, Lookup, TraitId, TypeAliasId, TypeParamId, VariantId,
+    AssocContainerId, GenericDefId, Lookup, TraitId, TypeAliasId, TypeParamId, VariantId,
 };
 use hir_expand::name::{name, Name};
@@ -155,8 +155,8 @@ fn parent_generic_def(db: &impl DefDatabase, def: GenericDefId) -> Option<Generi
    };
    match container {
-        ContainerId::ImplId(it) => Some(it.into()),
+        AssocContainerId::ImplId(it) => Some(it.into()),
-        ContainerId::TraitId(it) => Some(it.into()),
+        AssocContainerId::TraitId(it) => Some(it.into()),
-        ContainerId::ModuleId(_) => None,
+        AssocContainerId::ContainerId(_) => None,
    }
 }
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index b3c323d38..2c2b6fa48 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -1,24 +1,26 @@
 //! FIXME: write short doc here
-use ra_db::SourceDatabase;
+use hir::db::AstDatabase;
 use ra_syntax::{
-    algo::ancestors_at_offset,
    ast::{self, ArgListOwner},
-    match_ast, AstNode, SyntaxNode, TextUnit,
+    match_ast, AstNode, SyntaxNode,
 };
 use test_utils::tested_by;
-use crate::{db::RootDatabase, CallInfo, FilePosition, FunctionSignature};
+use crate::{
+    db::RootDatabase, expand::descend_into_macros, CallInfo, FilePosition, FunctionSignature,
+};
 /// Computes parameter information for the given call expression.
 pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
-    let parse = db.parse(position.file_id);
+    let file = db.parse_or_expand(position.file_id.into())?;
-    let syntax = parse.tree().syntax().clone();
+    let token = file.token_at_offset(position.offset).next()?;
+    let token = descend_into_macros(db, position.file_id, token);
    // Find the calling expression and it's NameRef
-    let calling_node = FnCallNode::with_node(&syntax, position.offset)?;
+    let calling_node = FnCallNode::with_node(&token.value.parent())?;
    let name_ref = calling_node.name_ref()?;
-    let name_ref = hir::InFile::new(position.file_id.into(), name_ref.syntax());
+    let name_ref = token.with_value(name_ref.syntax());
    let analyzer = hir::SourceAnalyzer::new(db, name_ref, None);
    let (mut call_info, has_self) = match &calling_node {
@@ -93,8 +95,8 @@ enum FnCallNode {
 }
 impl FnCallNode {
-    fn with_node(syntax: &SyntaxNode, offset: TextUnit) -> Option<FnCallNode> {
+    fn with_node(syntax: &SyntaxNode) -> Option<FnCallNode> {
-        ancestors_at_offset(syntax, offset).find_map(|node| {
+        syntax.ancestors().find_map(|node| {
            match_ast! {
                match node {
                    ast::CallExpr(it) => { Some(FnCallNode::CallExpr(it)) },
@@ -589,4 +591,25 @@ fn f() {
        assert_eq!(info.label(), "foo!()");
        assert_eq!(info.doc().map(|it| it.into()), Some("empty macro".to_string()));
    }
+    #[test]
+    fn fn_signature_for_call_in_macro() {
+        let info = call_info(
+            r#"
+            macro_rules! id {
+                ($($tt:tt)*) => { $($tt)* }
+            }
+            fn foo() {
+            }
+            id! {
+                fn bar() {
+                    foo(<|>);
+                }
+            }
+            "#,
+        );
+        assert_eq!(info.label(), "fn foo()");
+    }
 }
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index 6a6b49afd..b9ae67828 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -328,22 +328,23 @@ impl ToNav for hir::AssocItem {
 impl ToNav for hir::Local {
    fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
        let src = self.source(db);
-        let (full_range, focus_range) = match src.value {
+        let node = match &src.value {
-            Either::Left(it) => {
+            Either::Left(bind_pat) => {
-                (it.syntax().text_range(), it.name().map(|it| it.syntax().text_range()))
+                bind_pat.name().map_or_else(|| bind_pat.syntax().clone(), |it| it.syntax().clone())
            }
-            Either::Right(it) => (it.syntax().text_range(), Some(it.self_kw_token().text_range())),
+            Either::Right(it) => it.syntax().clone(),
        };
+        let full_range = original_range(db, src.with_value(&node));
        let name = match self.name(db) {
            Some(it) => it.to_string().into(),
            None => "".into(),
        };
        NavigationTarget {
-            file_id: src.file_id.original_file(db),
+            file_id: full_range.file_id,
            name,
            kind: BIND_PAT,
-            full_range,
+            full_range: full_range.range,
-            focus_range,
+            focus_range: None,
            container_name: None,
            description: None,
            docs: None,
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index bee8e9df2..9b5744789 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -225,35 +225,40 @@ mod tests {
    use crate::mock_analysis::analysis_and_position;
-    fn check_goto(fixture: &str, expected: &str) {
+    fn check_goto(fixture: &str, expected: &str, expected_range: &str) {
        let (analysis, pos) = analysis_and_position(fixture);
        let mut navs = analysis.goto_definition(pos).unwrap().unwrap().info;
        assert_eq!(navs.len(), 1);
-        let nav = navs.pop().unwrap();
-        nav.assert_match(expected);
-    }
-    fn check_goto_with_range_content(fixture: &str, expected: &str, expected_range: &str) {
-        let (analysis, pos) = analysis_and_position(fixture);
-        let mut navs = analysis.goto_definition(pos).unwrap().unwrap().info;
-        assert_eq!(navs.len(), 1);
        let nav = navs.pop().unwrap();
-        let file_text = analysis.file_text(pos.file_id).unwrap();
+        let file_text = analysis.file_text(nav.file_id()).unwrap();
+        let mut actual = file_text[nav.full_range()].to_string();
+        if let Some(focus) = nav.focus_range() {
+            actual += "|";
+            actual += &file_text[focus];
+        }
-        let actual_full_range = &file_text[nav.full_range()];
+        if !expected_range.contains("...") {
-        let actual_range = &file_text[nav.range()];
+            test_utils::assert_eq_text!(&actual, expected_range);
+        } else {
+            let mut parts = expected_range.split("...");
+            let prefix = parts.next().unwrap();
+            let suffix = parts.next().unwrap();
+            assert!(
+                actual.starts_with(prefix) && actual.ends_with(suffix),
+                "\nExpected: {}\n Actual: {}\n",
+                expected_range,
+                actual
+            );
+        }
-        test_utils::assert_eq_text!(
-            &format!("{}|{}", actual_full_range, actual_range),
-            expected_range
-        );
        nav.assert_match(expected);
    }
    #[test]
-    fn goto_definition_works_in_items() {
+    fn goto_def_in_items() {
        check_goto(
            "
            //- /lib.rs
@@ -261,11 +266,12 @@ mod tests {
            enum E { X(Foo<|>) }
            ",
            "Foo STRUCT_DEF FileId(1) [0; 11) [7; 10)",
+            "struct Foo;|Foo",
        );
    }
    #[test]
-    fn goto_definition_works_at_start_of_item() {
+    fn goto_def_at_start_of_item() {
        check_goto(
            "
            //- /lib.rs
@@ -273,6 +279,7 @@ mod tests {
            enum E { X(<|>Foo) }
            ",
            "Foo STRUCT_DEF FileId(1) [0; 11) [7; 10)",
+            "struct Foo;|Foo",
        );
    }
@@ -285,61 +292,65 @@ mod tests {
            mod a;
            mod b;
            enum E { X(Foo<|>) }
            //- /a.rs
            struct Foo;
            //- /b.rs
            struct Foo;
            ",
            "Foo STRUCT_DEF FileId(2) [0; 11) [7; 10)",
+            "struct Foo;|Foo",
        );
    }
    #[test]
-    fn goto_definition_works_for_module_declaration() {
+    fn goto_def_for_module_declaration() {
        check_goto(
            "
            //- /lib.rs
            mod <|>foo;
            //- /foo.rs
            // empty
            ",
            "foo SOURCE_FILE FileId(2) [0; 10)",
+            "// empty\n\n",
        );
        check_goto(
            "
            //- /lib.rs
            mod <|>foo;
            //- /foo/mod.rs
            // empty
            ",
            "foo SOURCE_FILE FileId(2) [0; 10)",
+            "// empty\n\n",
        );
    }
    #[test]
-    fn goto_definition_works_for_macros() {
+    fn goto_def_for_macros() {
-        covers!(goto_definition_works_for_macros);
+        covers!(goto_def_for_macros);
        check_goto(
            "
            //- /lib.rs
-            macro_rules! foo {
+            macro_rules! foo { () => { () } }
-                () => {
-                    {}
-                };
-            }
            fn bar() {
                <|>foo!();
            }
            ",
-            "foo MACRO_CALL FileId(1) [0; 50) [13; 16)",
+            "foo MACRO_CALL FileId(1) [0; 33) [13; 16)",
+            "macro_rules! foo { () => { () } }|foo",
        );
    }
    #[test]
-    fn goto_definition_works_for_macros_from_other_crates() {
+    fn goto_def_for_macros_from_other_crates() {
-        covers!(goto_definition_works_for_macros);
+        covers!(goto_def_for_macros);
        check_goto(
            "
            //- /lib.rs
@@ -350,18 +361,15 @@ mod tests {
            //- /foo/lib.rs
            #[macro_export]
-            macro_rules! foo {
+            macro_rules! foo { () => { () } }
-                () => {
-                    {}
-                };
-            }
            ",
-            "foo MACRO_CALL FileId(2) [0; 66) [29; 32)",
+            "foo MACRO_CALL FileId(2) [0; 49) [29; 32)",
+            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
        );
    }
    #[test]
-    fn goto_definition_works_for_macros_in_use_tree() {
+    fn goto_def_for_macros_in_use_tree() {
        check_goto(
            "
            //- /lib.rs
@@ -369,19 +377,16 @@ mod tests {
            //- /foo/lib.rs
            #[macro_export]
-            macro_rules! foo {
+            macro_rules! foo { () => { () } }
-                () => {
-                    {}
-                };
-            }
            ",
-            "foo MACRO_CALL FileId(2) [0; 66) [29; 32)",
+            "foo MACRO_CALL FileId(2) [0; 49) [29; 32)",
+            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
        );
    }
    #[test]
-    fn goto_definition_works_for_macro_defined_fn_with_arg() {
+    fn goto_def_for_macro_defined_fn_with_arg() {
-        check_goto_with_range_content(
+        check_goto(
            "
            //- /lib.rs
            macro_rules! define_fn {
@@ -400,8 +405,8 @@ mod tests {
    }
    #[test]
-    fn goto_definition_works_for_macro_defined_fn_no_arg() {
+    fn goto_def_for_macro_defined_fn_no_arg() {
-        check_goto_with_range_content(
+        check_goto(
            "
            //- /lib.rs
            macro_rules! define_fn {
@@ -420,27 +425,28 @@ mod tests {
    }
    #[test]
-    fn goto_definition_works_for_methods() {
+    fn goto_def_for_methods() {
-        covers!(goto_definition_works_for_methods);
+        covers!(goto_def_for_methods);
        check_goto(
            "
            //- /lib.rs
            struct Foo;
            impl Foo {
-                fn frobnicate(&self) {  }
+                fn frobnicate(&self) { }
            }
            fn bar(foo: &Foo) {
                foo.frobnicate<|>();
            }
            ",
-            "frobnicate FN_DEF FileId(1) [27; 52) [30; 40)",
+            "frobnicate FN_DEF FileId(1) [27; 51) [30; 40)",
+            "fn frobnicate(&self) { }|frobnicate",
        );
    }
    #[test]
-    fn goto_definition_works_for_fields() {
+    fn goto_def_for_fields() {
-        covers!(goto_definition_works_for_fields);
+        covers!(goto_def_for_fields);
        check_goto(
            "
            //- /lib.rs
@@ -453,12 +459,13 @@ mod tests {
            }
            ",
            "spam RECORD_FIELD_DEF FileId(1) [17; 26) [17; 21)",
+            "spam: u32|spam",
        );
    }
    #[test]
-    fn goto_definition_works_for_record_fields() {
+    fn goto_def_for_record_fields() {
-        covers!(goto_definition_works_for_record_fields);
+        covers!(goto_def_for_record_fields);
        check_goto(
            "
            //- /lib.rs
@@ -473,6 +480,7 @@ mod tests {
            }
            ",
            "spam RECORD_FIELD_DEF FileId(1) [17; 26) [17; 21)",
+            "spam: u32|spam",
        );
    }
@@ -489,29 +497,31 @@ mod tests {
            }
            ",
            "TUPLE_FIELD_DEF FileId(1) [11; 14)",
+            "u32",
        );
    }
    #[test]
-    fn goto_definition_works_for_ufcs_inherent_methods() {
+    fn goto_def_for_ufcs_inherent_methods() {
        check_goto(
            "
            //- /lib.rs
            struct Foo;
            impl Foo {
-                fn frobnicate() {  }
+                fn frobnicate() { }
            }
            fn bar(foo: &Foo) {
                Foo::frobnicate<|>();
            }
            ",
-            "frobnicate FN_DEF FileId(1) [27; 47) [30; 40)",
+            "frobnicate FN_DEF FileId(1) [27; 46) [30; 40)",
+            "fn frobnicate() { }|frobnicate",
        );
    }
    #[test]
-    fn goto_definition_works_for_ufcs_trait_methods_through_traits() {
+    fn goto_def_for_ufcs_trait_methods_through_traits() {
        check_goto(
            "
            //- /lib.rs
@@ -524,11 +534,12 @@ mod tests {
            }
            ",
            "frobnicate FN_DEF FileId(1) [16; 32) [19; 29)",
+            "fn frobnicate();|frobnicate",
        );
    }
    #[test]
-    fn goto_definition_works_for_ufcs_trait_methods_through_self() {
+    fn goto_def_for_ufcs_trait_methods_through_self() {
        check_goto(
            "
            //- /lib.rs
@@ -543,6 +554,7 @@ mod tests {
            }
            ",
            "frobnicate FN_DEF FileId(1) [30; 46) [33; 43)",
+            "fn frobnicate();|frobnicate",
        );
    }
@@ -559,6 +571,7 @@ mod tests {
            }
            ",
            "impl IMPL_BLOCK FileId(1) [12; 73)",
+            "impl Foo {...}",
        );
        check_goto(
@@ -572,6 +585,7 @@ mod tests {
            }
            ",
            "impl IMPL_BLOCK FileId(1) [12; 73)",
+            "impl Foo {...}",
        );
        check_goto(
@@ -585,6 +599,7 @@ mod tests {
            }
            ",
            "impl IMPL_BLOCK FileId(1) [15; 75)",
+            "impl Foo {...}",
        );
        check_goto(
@@ -597,6 +612,7 @@ mod tests {
            }
            ",
            "impl IMPL_BLOCK FileId(1) [15; 62)",
+            "impl Foo {...}",
        );
    }
@@ -616,6 +632,7 @@ mod tests {
            }
            ",
            "impl IMPL_BLOCK FileId(1) [49; 115)",
+            "impl Make for Foo {...}",
        );
        check_goto(
@@ -632,17 +649,19 @@ mod tests {
            }
            ",
            "impl IMPL_BLOCK FileId(1) [49; 115)",
+            "impl Make for Foo {...}",
        );
    }
    #[test]
-    fn goto_definition_works_when_used_on_definition_name_itself() {
+    fn goto_def_when_used_on_definition_name_itself() {
        check_goto(
            "
            //- /lib.rs
            struct Foo<|> { value: u32 }
            ",
            "Foo STRUCT_DEF FileId(1) [0; 25) [7; 10)",
+            "struct Foo { value: u32 }|Foo",
        );
        check_goto(
@@ -653,15 +672,16 @@ mod tests {
            }
            "#,
            "field RECORD_FIELD_DEF FileId(1) [17; 30) [17; 22)",
+            "field: string|field",
        );
        check_goto(
            "
            //- /lib.rs
-            fn foo_test<|>() {
+            fn foo_test<|>() { }
-            }
            ",
            "foo_test FN_DEF FileId(1) [0; 17) [3; 11)",
+            "fn foo_test() { }|foo_test",
        );
        check_goto(
@@ -672,6 +692,7 @@ mod tests {
            }
            ",
            "Foo ENUM_DEF FileId(1) [0; 25) [5; 8)",
+            "enum Foo {...}|Foo",
        );
        check_goto(
@@ -684,22 +705,25 @@ mod tests {
            }
            ",
            "Variant2 ENUM_VARIANT FileId(1) [29; 37) [29; 37)",
+            "Variant2|Variant2",
        );
        check_goto(
            r#"
            //- /lib.rs
-            static inner<|>: &str = "";
+            static INNER<|>: &str = "";
            "#,
-            "inner STATIC_DEF FileId(1) [0; 24) [7; 12)",
+            "INNER STATIC_DEF FileId(1) [0; 24) [7; 12)",
+            "static INNER: &str = \"\";|INNER",
        );
        check_goto(
            r#"
            //- /lib.rs
-            const inner<|>: &str = "";
+            const INNER<|>: &str = "";
            "#,
-            "inner CONST_DEF FileId(1) [0; 23) [6; 11)",
+            "INNER CONST_DEF FileId(1) [0; 23) [6; 11)",
+            "const INNER: &str = \"\";|INNER",
        );
        check_goto(
@@ -708,24 +732,25 @@ mod tests {
            type Thing<|> = Option<()>;
            "#,
            "Thing TYPE_ALIAS_DEF FileId(1) [0; 24) [5; 10)",
+            "type Thing = Option<()>;|Thing",
        );
        check_goto(
            r#"
            //- /lib.rs
-            trait Foo<|> {
+            trait Foo<|> { }
-            }
            "#,
            "Foo TRAIT_DEF FileId(1) [0; 13) [6; 9)",
+            "trait Foo { }|Foo",
        );
        check_goto(
            r#"
            //- /lib.rs
-            mod bar<|> {
+            mod bar<|> { }
-            }
            "#,
            "bar MODULE FileId(1) [0; 11) [4; 7)",
+            "mod bar { }|bar",
        );
    }
@@ -746,6 +771,7 @@ mod tests {
            mod confuse_index { fn foo(); }
            ",
            "foo FN_DEF FileId(1) [52; 63) [55; 58)",
+            "fn foo() {}|foo",
        );
    }
@@ -774,6 +800,7 @@ mod tests {
            }
            ",
            "foo FN_DEF FileId(1) [398; 415) [401; 404)",
+            "fn foo() -> i8 {}|foo",
        );
    }
@@ -787,6 +814,82 @@ mod tests {
            }
            ",
            "T TYPE_PARAM FileId(1) [11; 12)",
+            "T",
        );
    }
+    #[test]
+    fn goto_within_macro() {
+        check_goto(
+            "
+            //- /lib.rs
+            macro_rules! id {
+                ($($tt:tt)*) => ($($tt)*)
+            }
+            fn foo() {
+                let x = 1;
+                id!({
+                    let y = <|>x;
+                    let z = y;
+                });
+            }
+            ",
+            "x BIND_PAT FileId(1) [69; 70)",
+            "x",
+        );
+        check_goto(
+            "
+            //- /lib.rs
+            macro_rules! id {
+                ($($tt:tt)*) => ($($tt)*)
+            }
+            fn foo() {
+                let x = 1;
+                id!({
+                    let y = x;
+                    let z = <|>y;
+                });
+            }
+            ",
+            "y BIND_PAT FileId(1) [98; 99)",
+            "y",
+        );
+    }
+    #[test]
+    fn goto_def_in_local_fn() {
+        check_goto(
+            "
+            //- /lib.rs
+            fn main() {
+                fn foo() {
+                    let x = 92;
+                    <|>x;
+                }
+            }
+            ",
+            "x BIND_PAT FileId(1) [39; 40)",
+            "x",
+        );
+    }
+    #[test]
+    fn goto_def_for_field_init_shorthand() {
+        covers!(goto_def_for_field_init_shorthand);
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo { x: i32 }
+            fn main() {
+                let x = 92;
+                Foo { x<|> };
+            }
+            ",
+            "x RECORD_FIELD_DEF FileId(1) [13; 19) [13; 14)",
+            "x: i32|x",
+        )
+    }
 }
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 51e320128..a227bf546 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -250,7 +250,7 @@ pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
    } else {
        return None;
    };
-    Some(ty.display(db).to_string())
+    Some(ty.display_truncated(db, None).to_string())
 }
 #[cfg(test)]
@@ -425,6 +425,23 @@ mod tests {
    }
    #[test]
+    fn hover_omits_default_generic_types() {
+        check_hover_result(
+            r#"
+//- /main.rs
+struct Test<K, T = u8> {
+    k: K,
+    t: T,
+}
+fn main() {
+    let zz<|> = Test { t: 23, k: 33 };
+}"#,
+            &["Test<i32>"],
+        );
+    }
+    #[test]
    fn hover_some() {
        let (analysis, position) = single_file_with_position(
            "
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 3730121af..3154df457 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -160,6 +160,32 @@ mod tests {
    use crate::mock_analysis::single_file;
    #[test]
+    fn default_generic_types_should_not_be_displayed() {
+        let (analysis, file_id) = single_file(
+            r#"
+struct Test<K, T = u8> {
+    k: K,
+    t: T,
+}
+fn main() {
+    let zz = Test { t: 23, k: 33 };
+}"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
+        [
+            InlayHint {
+                range: [69; 71),
+                kind: TypeHint,
+                label: "Test<i32>",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn let_statement() {
        let (analysis, file_id) = single_file(
            r#"
diff --git a/crates/ra_ide/src/marks.rs b/crates/ra_ide/src/marks.rs
index 848ae4dc7..077a44473 100644
--- a/crates/ra_ide/src/marks.rs
+++ b/crates/ra_ide/src/marks.rs
@@ -3,10 +3,11 @@
 test_utils::marks!(
    inserts_angle_brackets_for_generics
    inserts_parens_for_function_calls
-    goto_definition_works_for_macros
+    goto_def_for_macros
-    goto_definition_works_for_methods
+    goto_def_for_methods
-    goto_definition_works_for_fields
+    goto_def_for_fields
-    goto_definition_works_for_record_fields
+    goto_def_for_record_fields
+    goto_def_for_field_init_shorthand
    call_info_bad_offset
    dont_complete_current_use
    dont_complete_primitive_in_use
diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs
index c1f091ec0..3483a7176 100644
--- a/crates/ra_ide/src/references/classify.rs
+++ b/crates/ra_ide/src/references/classify.rs
@@ -134,21 +134,22 @@ pub(crate) fn classify_name_ref(
    let analyzer = SourceAnalyzer::new(db, name_ref.map(|it| it.syntax()), None);
    if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
-        tested_by!(goto_definition_works_for_methods);
+        tested_by!(goto_def_for_methods);
        if let Some(func) = analyzer.resolve_method_call(&method_call) {
            return Some(from_assoc_item(db, func.into()));
        }
    }
    if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
-        tested_by!(goto_definition_works_for_fields);
+        tested_by!(goto_def_for_fields);
        if let Some(field) = analyzer.resolve_field(&field_expr) {
            return Some(from_struct_field(db, field));
        }
    }
    if let Some(record_field) = ast::RecordField::cast(parent.clone()) {
-        tested_by!(goto_definition_works_for_record_fields);
+        tested_by!(goto_def_for_record_fields);
+        tested_by!(goto_def_for_field_init_shorthand);
        if let Some(field_def) = analyzer.resolve_record_field(&record_field) {
            return Some(from_struct_field(db, field_def));
        }
@@ -160,7 +161,7 @@ pub(crate) fn classify_name_ref(
    let visibility = None;
    if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
-        tested_by!(goto_definition_works_for_macros);
+        tested_by!(goto_def_for_macros);
        if let Some(macro_def) = analyzer.resolve_macro_call(db, name_ref.with_value(&macro_call)) {
            let kind = NameKind::Macro(macro_def);
            return Some(NameDefinition { kind, container, visibility });
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 2157139f6..a097cf8e8 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -5,6 +5,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .comment            { color: #7F9F7F; }
 .string             { color: #CC9393; }
+.field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
@@ -39,7 +40,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut">vec</span> = <span class="text">Vec</span>::<span class="text">new</span>();
    <span class="keyword.control">if</span> <span class="keyword">true</span> {
-        <span class="variable.mut">vec</span>.<span class="text">push</span>(<span class="type">Foo</span> { <span class="field">x</span>: <span class="literal.numeric">0</span>, <span class="field">y</span>: <span class="literal.numeric">1</span> });
+        <span class="keyword">let</span> <span class="variable">x</span> = <span class="literal.numeric">92</span>;
+        <span class="variable.mut">vec</span>.<span class="text">push</span>(<span class="type">Foo</span> { <span class="field">x</span>, <span class="field">y</span>: <span class="literal.numeric">1</span> });
    }
    <span class="keyword.unsafe">unsafe</span> { <span class="variable.mut">vec</span>.<span class="text">set_len</span>(<span class="literal.numeric">0</span>); }
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index 871a52cf6..110556c09 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -5,6 +5,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .comment            { color: #7F9F7F; }
 .string             { color: #CC9393; }
+.field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 15e75709c..657c7b21a 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -102,11 +102,10 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
            COMMENT => tags::LITERAL_COMMENT,
            STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => tags::LITERAL_STRING,
            ATTR => tags::LITERAL_ATTRIBUTE,
+            // Special-case field init shorthand
+            NAME_REF if node.parent().and_then(ast::RecordField::cast).is_some() => tags::FIELD,
+            NAME_REF if node.ancestors().any(|it| it.kind() == ATTR) => continue,
            NAME_REF => {
-                if node.ancestors().any(|it| it.kind() == ATTR) {
-                    continue;
-                }
                let name_ref = node.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
                let name_kind =
                    classify_name_ref(db, InFile::new(file_id.into(), &name_ref)).map(|d| d.kind);
@@ -282,6 +281,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .comment            { color: #7F9F7F; }
 .string             { color: #CC9393; }
+.field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
@@ -327,7 +327,8 @@ fn main() {
    let mut vec = Vec::new();
    if true {
-        vec.push(Foo { x: 0, y: 1 });
+        let x = 92;
+        vec.push(Foo { x, y: 1 });
    }
    unsafe { vec.set_len(0); }
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index 2c60430d1..ea2cac069 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -476,7 +476,7 @@ impl<'a> TreeSink for TtTreeSink<'a> {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::tests::{create_rules, expand};
+    use crate::tests::parse_macro;
    use ra_parser::TokenSource;
    use ra_syntax::{
        algo::{insert_children, InsertPosition},
@@ -485,7 +485,7 @@ mod tests {
    #[test]
    fn convert_tt_token_source() {
-        let rules = create_rules(
+        let expansion = parse_macro(
            r#"
            macro_rules! literals {
                ($i:ident) => {
@@ -498,8 +498,8 @@ mod tests {
                }
            }
            "#,
-        );
+        )
-        let expansion = expand(&rules, "literals!(foo);");
+        .expand_tt("literals!(foo);");
        let tts = &[expansion.into()];
        let buffer = tt::buffer::TokenBuffer::new(tts);
        let mut tt_src = SubtreeTokenSource::new(&buffer);
@@ -527,7 +527,7 @@ mod tests {
    #[test]
    fn stmts_token_trees_to_expr_is_err() {
-        let rules = create_rules(
+        let expansion = parse_macro(
            r#"
            macro_rules! stmts {
                () => {
@@ -538,8 +538,8 @@ mod tests {
                }
            }
            "#,
-        );
+        )
-        let expansion = expand(&rules, "stmts!();");
+        .expand_tt("stmts!();");
        assert!(token_tree_to_syntax_node(&expansion, FragmentKind::Expr).is_err());
    }
diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs
index ff225f0db..e640d115b 100644
--- a/crates/ra_mbe/src/tests.rs
+++ b/crates/ra_mbe/src/tests.rs
@@ -1,5 +1,7 @@
+use std::fmt::Write;
 use ra_parser::FragmentKind;
-use ra_syntax::{ast, AstNode, NodeOrToken, WalkEvent};
+use ra_syntax::{ast, AstNode, NodeOrToken, SyntaxKind::IDENT, SyntaxNode, WalkEvent, T};
 use test_utils::assert_eq_text;
 use super::*;
@@ -61,13 +63,14 @@ mod rule_parsing {
 #[test]
 fn test_token_id_shift() {
-    let macro_definition = r#"
+    let expansion = parse_macro(
+        r#"
 macro_rules! foobar {
    ($e:ident) => { foo bar $e }
 }
-"#;
+"#,
-    let rules = create_rules(macro_definition);
+    )
-    let expansion = expand(&rules, "foobar!(baz);");
+    .expand_tt("foobar!(baz);");
    fn get_id(t: &tt::TokenTree) -> Option<u32> {
        if let tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) = t {
@@ -90,22 +93,23 @@ macro_rules! foobar {
 #[test]
 fn test_token_map() {
-    use ra_parser::SyntaxKind::*;
+    let expanded = parse_macro(
-    use ra_syntax::T;
+        r#"
-    let macro_definition = r#"
 macro_rules! foobar {
    ($e:ident) => { fn $e() {} }
 }
-"#;
+"#,
-    let rules = create_rules(macro_definition);
+    )
-    let (expansion, (token_map, content)) = expand_and_map(&rules, "foobar!(baz);");
+    .expand_tt("foobar!(baz);");
+    let (node, token_map) = token_tree_to_syntax_node(&expanded, FragmentKind::Items).unwrap();
+    let content = node.syntax_node().to_string();
    let get_text = |id, kind| -> String {
        content[token_map.range_by_token(id).unwrap().by_kind(kind).unwrap()].to_string()
    };
-    assert_eq!(expansion.token_trees.len(), 4);
+    assert_eq!(expanded.token_trees.len(), 4);
    // {($e:ident) => { fn $e() {} }}
    // 012345      67 8 9  T12  3
@@ -116,7 +120,7 @@ macro_rules! foobar {
 #[test]
 fn test_convert_tt() {
-    let macro_definition = r#"
+    parse_macro(r#"
 macro_rules! impl_froms {
    ($e:ident: $($v:ident),*) => {
        $(
@@ -128,24 +132,17 @@ macro_rules! impl_froms {
        )*
    }
 }
-"#;
+"#)
+        .assert_expand_tt(
-    let macro_invocation = r#"
+            "impl_froms!(TokenTree: Leaf, Subtree);",
-impl_froms!(TokenTree: Leaf, Subtree);
+            "impl From <Leaf > for TokenTree {fn from (it : Leaf) -> TokenTree {TokenTree ::Leaf (it)}} \
-"#;
+             impl From <Subtree > for TokenTree {fn from (it : Subtree) -> TokenTree {TokenTree ::Subtree (it)}}"
+        );
-    let rules = create_rules(macro_definition);
-    let expansion = expand(&rules, macro_invocation);
-    assert_eq!(
-        expansion.to_string(),
-        "impl From <Leaf > for TokenTree {fn from (it : Leaf) -> TokenTree {TokenTree ::Leaf (it)}} \
-         impl From <Subtree > for TokenTree {fn from (it : Subtree) -> TokenTree {TokenTree ::Subtree (it)}}"
-    )
 }
 #[test]
 fn test_expr_order() {
-    let rules = create_rules(
+    let expanded = parse_macro(
        r#"
        macro_rules! foo {
            ($ i:expr) => {
@@ -153,11 +150,10 @@ fn test_expr_order() {
            }
        }
 "#,
-    );
+    )
-    let expanded = expand(&rules, "foo! { 1 + 1}");
+    .expand_items("foo! { 1 + 1}");
-    let tree = token_tree_to_syntax_node(&expanded, FragmentKind::Items).unwrap().0.syntax_node();
-    let dump = format!("{:#?}", tree);
+    let dump = format!("{:#?}", expanded);
    assert_eq_text!(
        dump.trim(),
        r#"MACRO_ITEMS@[0; 15)
@@ -189,7 +185,7 @@ fn test_expr_order() {
 #[test]
 fn test_fail_match_pattern_by_first_token() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:ident) => (
@@ -203,16 +199,15 @@ fn test_fail_match_pattern_by_first_token() {
            )
        }
 "#,
-    );
+    )
+    .assert_expand_items("foo! { foo }", "mod foo {}")
-    assert_expansion(MacroKind::Items, &rules, "foo! { foo }", "mod foo {}");
+    .assert_expand_items("foo! { = bar }", "fn bar () {}")
-    assert_expansion(MacroKind::Items, &rules, "foo! { = bar }", "fn bar () {}");
+    .assert_expand_items("foo! { + Baz }", "struct Baz ;");
-    assert_expansion(MacroKind::Items, &rules, "foo! { + Baz }", "struct Baz ;");
 }
 #[test]
 fn test_fail_match_pattern_by_last_token() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:ident) => (
@@ -226,16 +221,15 @@ fn test_fail_match_pattern_by_last_token() {
            )
        }
 "#,
-    );
+    )
+    .assert_expand_items("foo! { foo }", "mod foo {}")
-    assert_expansion(MacroKind::Items, &rules, "foo! { foo }", "mod foo {}");
+    .assert_expand_items("foo! { bar = }", "fn bar () {}")
-    assert_expansion(MacroKind::Items, &rules, "foo! { bar = }", "fn bar () {}");
+    .assert_expand_items("foo! { Baz + }", "struct Baz ;");
-    assert_expansion(MacroKind::Items, &rules, "foo! { Baz + }", "struct Baz ;");
 }
 #[test]
 fn test_fail_match_pattern_by_word_token() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:ident) => (
@@ -249,16 +243,15 @@ fn test_fail_match_pattern_by_word_token() {
            )
        }
 "#,
-    );
+    )
+    .assert_expand_items("foo! { foo }", "mod foo {}")
-    assert_expansion(MacroKind::Items, &rules, "foo! { foo }", "mod foo {}");
+    .assert_expand_items("foo! { spam bar }", "fn bar () {}")
-    assert_expansion(MacroKind::Items, &rules, "foo! { spam bar }", "fn bar () {}");
+    .assert_expand_items("foo! { eggs Baz }", "struct Baz ;");
-    assert_expansion(MacroKind::Items, &rules, "foo! { eggs Baz }", "struct Baz ;");
 }
 #[test]
 fn test_match_group_pattern_by_separator_token() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ ($ i:ident),*) => ($ (
@@ -273,16 +266,15 @@ fn test_match_group_pattern_by_separator_token() {
            )
        }
 "#,
-    );
+    )
+    .assert_expand_items("foo! { foo, bar }", "mod foo {} mod bar {}")
-    assert_expansion(MacroKind::Items, &rules, "foo! { foo, bar }", "mod foo {} mod bar {}");
+    .assert_expand_items("foo! { foo# bar }", "fn foo () {} fn bar () {}")
-    assert_expansion(MacroKind::Items, &rules, "foo! { foo# bar }", "fn foo () {} fn bar () {}");
+    .assert_expand_items("foo! { Foo,# Bar }", "struct Foo ; struct Bar ;");
-    assert_expansion(MacroKind::Items, &rules, "foo! { Foo,# Bar }", "struct Foo ; struct Bar ;");
 }
 #[test]
 fn test_match_group_pattern_with_multiple_defs() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ ($ i:ident),*) => ( struct Bar { $ (
@@ -290,19 +282,13 @@ fn test_match_group_pattern_with_multiple_defs() {
            )*} );
        }
 "#,
-    );
+    )
+    .assert_expand_items("foo! { foo, bar }", "struct Bar {fn foo {} fn bar {}}");
-    assert_expansion(
-        MacroKind::Items,
-        &rules,
-        "foo! { foo, bar }",
-        "struct Bar {fn foo {} fn bar {}}",
-    );
 }
 #[test]
 fn test_match_group_pattern_with_multiple_statement() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ ($ i:ident),*) => ( fn baz { $ (
@@ -310,14 +296,13 @@ fn test_match_group_pattern_with_multiple_statement() {
            )*} );
        }
 "#,
-    );
+    )
+    .assert_expand_items("foo! { foo, bar }", "fn baz {foo () ; bar () ;}");
-    assert_expansion(MacroKind::Items, &rules, "foo! { foo, bar }", "fn baz {foo () ; bar () ;}");
 }
 #[test]
 fn test_match_group_pattern_with_multiple_statement_without_semi() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ ($ i:ident),*) => ( fn baz { $ (
@@ -325,14 +310,13 @@ fn test_match_group_pattern_with_multiple_statement_without_semi() {
            );*} );
        }
 "#,
-    );
+    )
+    .assert_expand_items("foo! { foo, bar }", "fn baz {foo () ;bar ()}");
-    assert_expansion(MacroKind::Items, &rules, "foo! { foo, bar }", "fn baz {foo () ;bar ()}");
 }
 #[test]
 fn test_match_group_empty_fixed_token() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ ($ i:ident)* #abc) => ( fn baz { $ (
@@ -340,69 +324,59 @@ fn test_match_group_empty_fixed_token() {
            )*} );
        }
 "#,
-    );
+    )
+    .assert_expand_items("foo! {#abc}", "fn baz {}");
-    assert_expansion(MacroKind::Items, &rules, "foo! {#abc}", "fn baz {}");
 }
 #[test]
 fn test_match_group_in_subtree() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            (fn $name:ident {$($i:ident)*} ) => ( fn $name() { $ (
                $ i ();
            )*} );
        }"#,
-    );
+    )
+    .assert_expand_items("foo! {fn baz {a b} }", "fn baz () {a () ; b () ;}");
-    assert_expansion(MacroKind::Items, &rules, "foo! {fn baz {a b} }", "fn baz () {a () ; b () ;}");
 }
 #[test]
 fn test_match_group_with_multichar_sep() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            (fn $name:ident {$($i:literal)*} ) => ( fn $name() -> bool { $($i)&&*} );
        }"#,
-    );
+    )
+    .assert_expand_items("foo! (fn baz {true true} );", "fn baz () -> bool {true &&true}");
-    assert_expansion(
-        MacroKind::Items,
-        &rules,
-        "foo! (fn baz {true true} );",
-        "fn baz () -> bool {true &&true}",
-    );
 }
 #[test]
 fn test_match_group_zero_match() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ( $($i:ident)* ) => ();
        }"#,
-    );
+    )
+    .assert_expand_items("foo! ();", "");
-    assert_expansion(MacroKind::Items, &rules, "foo! ();", "");
 }
 #[test]
 fn test_match_group_in_group() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            { $( ( $($i:ident)* ) )* } => ( $( ( $($i)* ) )* );
        }"#,
-    );
+    )
+    .assert_expand_items("foo! ( (a b) );", "(a b)");
-    assert_expansion(MacroKind::Items, &rules, "foo! ( (a b) );", "(a b)");
 }
 #[test]
 fn test_expand_to_item_list() {
-    let rules = create_rules(
+    let tree = parse_macro(
        "
            macro_rules! structs {
                ($($i:ident),*) => {
@@ -410,9 +384,8 @@ fn test_expand_to_item_list() {
                }
            }
            ",
-    );
+    )
-    let expansion = expand(&rules, "structs!(Foo, Bar);");
+    .expand_items("structs!(Foo, Bar);");
-    let tree = token_tree_to_syntax_node(&expansion, FragmentKind::Items).unwrap().0.syntax_node();
    assert_eq!(
        format!("{:#?}", tree).trim(),
        r#"
@@ -469,7 +442,7 @@ fn test_expand_literals_to_token_tree() {
        unreachable!("It is not a literal");
    }
-    let rules = create_rules(
+    let expansion = parse_macro(
        r#"
            macro_rules! literals {
                ($i:ident) => {
@@ -482,8 +455,8 @@ fn test_expand_literals_to_token_tree() {
                }
            }
            "#,
-    );
+    )
-    let expansion = expand(&rules, "literals!(foo);");
+    .expand_tt("literals!(foo);");
    let stm_tokens = &to_subtree(&expansion.token_trees[0]).token_trees;
    // [let] [a] [=] ['c'] [;]
@@ -498,7 +471,7 @@ fn test_expand_literals_to_token_tree() {
 #[test]
 fn test_two_idents() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:ident, $ j:ident) => {
@@ -506,18 +479,13 @@ fn test_two_idents() {
            }
        }
 "#,
-    );
+    )
-    assert_expansion(
+    .assert_expand_items("foo! { foo, bar }", "fn foo () {let a = foo ; let b = bar ;}");
-        MacroKind::Items,
-        &rules,
-        "foo! { foo, bar }",
-        "fn foo () {let a = foo ; let b = bar ;}",
-    );
 }
 #[test]
 fn test_tt_to_stmts() {
-    let rules = create_rules(
+    let stmts = parse_macro(
        r#"
        macro_rules! foo {
            () => {
@@ -527,11 +495,8 @@ fn test_tt_to_stmts() {
            }
        }
 "#,
-    );
+    )
+    .expand_statements("foo!{}");
-    let expanded = expand(&rules, "foo!{}");
-    let stmts =
-        token_tree_to_syntax_node(&expanded, FragmentKind::Statements).unwrap().0.syntax_node();
    assert_eq!(
        format!("{:#?}", stmts).trim(),
@@ -571,7 +536,7 @@ fn test_tt_to_stmts() {
 #[test]
 fn test_match_literal() {
-    let rules = create_rules(
+    parse_macro(
        r#"
    macro_rules! foo {
        ('(') => {
@@ -579,8 +544,8 @@ fn test_match_literal() {
        }
    }
 "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, "foo! ['('];", "fn foo () {}");
+    .assert_expand_items("foo! ['('];", "fn foo () {}");
 }
 // The following tests are port from intellij-rust directly
@@ -588,7 +553,7 @@ fn test_match_literal() {
 #[test]
 fn test_path() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:path) => {
@@ -596,11 +561,9 @@ fn test_path() {
            }
        }
 "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, "foo! { foo }", "fn foo () {let a = foo ;}");
+    .assert_expand_items("foo! { foo }", "fn foo () {let a = foo ;}")
-    assert_expansion(
+    .assert_expand_items(
-        MacroKind::Items,
-        &rules,
        "foo! { bar::<u8>::baz::<u8> }",
        "fn foo () {let a = bar ::< u8 >:: baz ::< u8 > ;}",
    );
@@ -608,7 +571,7 @@ fn test_path() {
 #[test]
 fn test_two_paths() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:path, $ j:path) => {
@@ -616,18 +579,13 @@ fn test_two_paths() {
            }
        }
 "#,
-    );
+    )
-    assert_expansion(
+    .assert_expand_items("foo! { foo, bar }", "fn foo () {let a = foo ; let b = bar ;}");
-        MacroKind::Items,
-        &rules,
-        "foo! { foo, bar }",
-        "fn foo () {let a = foo ; let b = bar ;}",
-    );
 }
 #[test]
 fn test_path_with_path() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:path) => {
@@ -635,13 +593,13 @@ fn test_path_with_path() {
            }
        }
 "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, "foo! { foo }", "fn foo () {let a = foo :: bar ;}");
+    .assert_expand_items("foo! { foo }", "fn foo () {let a = foo :: bar ;}");
 }
 #[test]
 fn test_expr() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:expr) => {
@@ -649,11 +607,8 @@ fn test_expr() {
            }
        }
 "#,
-    );
+    )
+    .assert_expand_items(
-    assert_expansion(
-        MacroKind::Items,
-        &rules,
        "foo! { 2 + 2 * baz(3).quux() }",
        "fn bar () {2 + 2 * baz (3) . quux () ;}",
    );
@@ -661,7 +616,7 @@ fn test_expr() {
 #[test]
 fn test_last_expr() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! vec {
            ($($item:expr),*) => {
@@ -675,10 +630,8 @@ fn test_last_expr() {
            };
        }
 "#,
-    );
+    )
-    assert_expansion(
+    .assert_expand_items(
-        MacroKind::Items,
-        &rules,
        "vec!(1,2,3);",
        "{let mut v = Vec :: new () ; v . push (1) ; v . push (2) ; v . push (3) ; v}",
    );
@@ -686,7 +639,7 @@ fn test_last_expr() {
 #[test]
 fn test_ty() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:ty) => (
@@ -694,18 +647,13 @@ fn test_ty() {
            )
        }
 "#,
-    );
+    )
-    assert_expansion(
+    .assert_expand_items("foo! { Baz<u8> }", "fn bar () -> Baz < u8 > {unimplemented ! ()}");
-        MacroKind::Items,
-        &rules,
-        "foo! { Baz<u8> }",
-        "fn bar () -> Baz < u8 > {unimplemented ! ()}",
-    );
 }
 #[test]
 fn test_ty_with_complex_type() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:ty) => (
@@ -713,20 +661,14 @@ fn test_ty_with_complex_type() {
            )
        }
 "#,
-    );
+    )
    // Reference lifetime struct with generic type
-    assert_expansion(
+    .assert_expand_items(
-        MacroKind::Items,
-        &rules,
        "foo! { &'a Baz<u8> }",
        "fn bar () -> & 'a Baz < u8 > {unimplemented ! ()}",
-    );
+    )
    // extern "Rust" func type
-    assert_expansion(
+    .assert_expand_items(
-        MacroKind::Items,
-        &rules,
        r#"foo! { extern "Rust" fn() -> Ret }"#,
        r#"fn bar () -> extern "Rust" fn () -> Ret {unimplemented ! ()}"#,
    );
@@ -734,19 +676,19 @@ fn test_ty_with_complex_type() {
 #[test]
 fn test_pat_() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:pat) => { fn foo() { let $ i; } }
        }
 "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, "foo! { (a, b) }", "fn foo () {let (a , b) ;}");
+    .assert_expand_items("foo! { (a, b) }", "fn foo () {let (a , b) ;}");
 }
 #[test]
 fn test_stmt() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:stmt) => (
@@ -754,14 +696,14 @@ fn test_stmt() {
            )
        }
 "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, "foo! { 2 }", "fn bar () {2 ;}");
+    .assert_expand_items("foo! { 2 }", "fn bar () {2 ;}")
-    assert_expansion(MacroKind::Items, &rules, "foo! { let a = 0 }", "fn bar () {let a = 0 ;}");
+    .assert_expand_items("foo! { let a = 0 }", "fn bar () {let a = 0 ;}");
 }
 #[test]
 fn test_single_item() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:item) => (
@@ -769,13 +711,13 @@ fn test_single_item() {
            )
        }
 "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, "foo! {mod c {}}", "mod c {}");
+    .assert_expand_items("foo! {mod c {}}", "mod c {}");
 }
 #[test]
 fn test_all_items() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ ($ i:item)*) => ($ (
@@ -783,10 +725,8 @@ fn test_all_items() {
            )*)
        }
 "#,
-    );
+    ).
-    assert_expansion(
+    assert_expand_items(
-        MacroKind::Items,
-        &rules,
        r#"
        foo! {
            extern crate a;
@@ -810,19 +750,19 @@ fn test_all_items() {
 #[test]
 fn test_block() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:block) => { fn foo() $ i }
        }
 "#,
-    );
+    )
-    assert_expansion(MacroKind::Stmts, &rules, "foo! { { 1; } }", "fn foo () {1 ;}");
+    .assert_expand_statements("foo! { { 1; } }", "fn foo () {1 ;}");
 }
 #[test]
 fn test_meta() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($ i:meta) => (
@@ -831,10 +771,8 @@ fn test_meta() {
            )
        }
 "#,
-    );
+    )
-    assert_expansion(
+    .assert_expand_items(
-        MacroKind::Items,
-        &rules,
        r#"foo! { cfg(target_os = "windows") }"#,
        r#"# [cfg (target_os = "windows")] fn bar () {}"#,
    );
@@ -842,7 +780,7 @@ fn test_meta() {
 #[test]
 fn test_meta_doc_comments() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
            ($(#[$ i:meta])+) => (
@@ -851,10 +789,8 @@ fn test_meta_doc_comments() {
            )
        }
 "#,
-    );
+    ).
-    assert_expansion(
+    assert_expand_items(
-        MacroKind::Items,
-        &rules,
        r#"foo! {
            /// Single Line Doc 1
            /**
@@ -867,69 +803,68 @@ fn test_meta_doc_comments() {
 #[test]
 fn test_tt_block() {
-    let rules = create_rules(
+    parse_macro(
        r#"
            macro_rules! foo {
                ($ i:tt) => { fn foo() $ i }
            }
    "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, r#"foo! { { 1; } }"#, r#"fn foo () {1 ;}"#);
+    .assert_expand_items(r#"foo! { { 1; } }"#, r#"fn foo () {1 ;}"#);
 }
 #[test]
 fn test_tt_group() {
-    let rules = create_rules(
+    parse_macro(
        r#"
            macro_rules! foo {
                 ($($ i:tt)*) => { $($ i)* }
            }
    "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, r#"foo! { fn foo() {} }"#, r#"fn foo () {}"#);
+    .assert_expand_items(r#"foo! { fn foo() {} }"#, r#"fn foo () {}"#);
 }
 #[test]
 fn test_lifetime() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
              ($ lt:lifetime) => { struct Ref<$ lt>{ s: &$ lt str } }
        }
 "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, r#"foo!{'a}"#, r#"struct Ref <'a > {s : &'a str}"#);
+    .assert_expand_items(r#"foo!{'a}"#, r#"struct Ref <'a > {s : &'a str}"#);
 }
 #[test]
 fn test_literal() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
              ($ type:ty $ lit:literal) => { const VALUE: $ type = $ lit;};
        }
 "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, r#"foo!(u8 0);"#, r#"const VALUE : u8 = 0 ;"#);
+    .assert_expand_items(r#"foo!(u8 0);"#, r#"const VALUE : u8 = 0 ;"#);
 }
 #[test]
 fn test_vis() {
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! foo {
              ($ vis:vis $ name:ident) => { $ vis fn $ name() {}};
        }
 "#,
-    );
+    )
-    assert_expansion(MacroKind::Items, &rules, r#"foo!(pub foo);"#, r#"pub fn foo () {}"#);
+    .assert_expand_items(r#"foo!(pub foo);"#, r#"pub fn foo () {}"#)
+    // test optional cases
-    // test optional casse
+    .assert_expand_items(r#"foo!(foo);"#, r#"fn foo () {}"#);
-    assert_expansion(MacroKind::Items, &rules, r#"foo!(foo);"#, r#"fn foo () {}"#);
 }
 #[test]
 fn test_inner_macro_rules() {
-    let rules = create_rules(
+    parse_macro(
        r#"
 macro_rules! foo {
    ($a:ident, $b:ident, $c:tt) => {
@@ -945,10 +880,8 @@ macro_rules! foo {
    }
 }
 "#,
-    );
+    ).
-    assert_expansion(
+    assert_expand_items(
-        MacroKind::Items,
-        &rules,
        r#"foo!(x,y, 1);"#,
        r#"macro_rules ! bar {($ bi : ident) => {fn $ bi () -> u8 {1}}} bar ! (x) ; fn y () -> u8 {1}"#,
    );
@@ -957,7 +890,7 @@ macro_rules! foo {
 // The following tests are based on real world situations
 #[test]
 fn test_vec() {
-    let rules = create_rules(
+    let fixture = parse_macro(
        r#"
         macro_rules! vec {
            ($($item:expr),*) => {
@@ -972,16 +905,14 @@ fn test_vec() {
 }
 "#,
    );
-    assert_expansion(MacroKind::Items, &rules, r#"vec!();"#, r#"{let mut v = Vec :: new () ; v}"#);
+    fixture
-    assert_expansion(
+        .assert_expand_items(r#"vec!();"#, r#"{let mut v = Vec :: new () ; v}"#)
-        MacroKind::Items,
+        .assert_expand_items(
-        &rules,
+            r#"vec![1u32,2];"#,
-        r#"vec![1u32,2];"#,
+            r#"{let mut v = Vec :: new () ; v . push (1u32) ; v . push (2) ; v}"#,
-        r#"{let mut v = Vec :: new () ; v . push (1u32) ; v . push (2) ; v}"#,
+        );
-    );
-    let expansion = expand(&rules, r#"vec![1u32,2];"#);
+    let tree = fixture.expand_expr(r#"vec![1u32,2];"#);
-    let tree = token_tree_to_syntax_node(&expansion, FragmentKind::Expr).unwrap().0.syntax_node();
    assert_eq!(
        format!("{:#?}", tree).trim(),
@@ -1055,7 +986,7 @@ fn test_vec() {
 fn test_winapi_struct() {
    // from https://github.com/retep998/winapi-rs/blob/a7ef2bca086aae76cf6c4ce4c2552988ed9798ad/src/macros.rs#L366
-    let rules = create_rules(
+    parse_macro(
        r#"
 macro_rules! STRUCT {
    ($(#[$attrs:meta])* struct $name:ident {
@@ -1077,17 +1008,19 @@ macro_rules! STRUCT {
    );
 }
 "#,
-    );
+    ).
    // from https://github.com/retep998/winapi-rs/blob/a7ef2bca086aae76cf6c4ce4c2552988ed9798ad/src/shared/d3d9caps.rs
-    assert_expansion(MacroKind::Items, &rules, r#"STRUCT!{struct D3DVSHADERCAPS2_0 {Caps: u8,}}"#,
+    assert_expand_items(r#"STRUCT!{struct D3DVSHADERCAPS2_0 {Caps: u8,}}"#,
-        "# [repr (C)] # [derive (Copy)] pub struct D3DVSHADERCAPS2_0 {pub Caps : u8 ,} impl Clone for D3DVSHADERCAPS2_0 {# [inline] fn clone (& self) -> D3DVSHADERCAPS2_0 {* self}} # [cfg (feature = \"impl-default\")] impl Default for D3DVSHADERCAPS2_0 {# [inline] fn default () -> D3DVSHADERCAPS2_0 {unsafe {$crate :: _core :: mem :: zeroed ()}}}");
+        "# [repr (C)] # [derive (Copy)] pub struct D3DVSHADERCAPS2_0 {pub Caps : u8 ,} impl Clone for D3DVSHADERCAPS2_0 {# [inline] fn clone (& self) -> D3DVSHADERCAPS2_0 {* self}} # [cfg (feature = \"impl-default\")] impl Default for D3DVSHADERCAPS2_0 {# [inline] fn default () -> D3DVSHADERCAPS2_0 {unsafe {$crate :: _core :: mem :: zeroed ()}}}"
-    assert_expansion(MacroKind::Items, &rules, r#"STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct D3DCONTENTPROTECTIONCAPS {Caps : u8 ,}}"#,
+    )
-        "# [repr (C)] # [derive (Copy)] # [cfg_attr (target_arch = \"x86\" , repr (packed))] pub struct D3DCONTENTPROTECTIONCAPS {pub Caps : u8 ,} impl Clone for D3DCONTENTPROTECTIONCAPS {# [inline] fn clone (& self) -> D3DCONTENTPROTECTIONCAPS {* self}} # [cfg (feature = \"impl-default\")] impl Default for D3DCONTENTPROTECTIONCAPS {# [inline] fn default () -> D3DCONTENTPROTECTIONCAPS {unsafe {$crate :: _core :: mem :: zeroed ()}}}");
+    .assert_expand_items(r#"STRUCT!{#[cfg_attr(target_arch = "x86", repr(packed))] struct D3DCONTENTPROTECTIONCAPS {Caps : u8 ,}}"#,
+        "# [repr (C)] # [derive (Copy)] # [cfg_attr (target_arch = \"x86\" , repr (packed))] pub struct D3DCONTENTPROTECTIONCAPS {pub Caps : u8 ,} impl Clone for D3DCONTENTPROTECTIONCAPS {# [inline] fn clone (& self) -> D3DCONTENTPROTECTIONCAPS {* self}} # [cfg (feature = \"impl-default\")] impl Default for D3DCONTENTPROTECTIONCAPS {# [inline] fn default () -> D3DCONTENTPROTECTIONCAPS {unsafe {$crate :: _core :: mem :: zeroed ()}}}"
+    );
 }
 #[test]
 fn test_int_base() {
-    let rules = create_rules(
+    parse_macro(
        r#"
 macro_rules! int_base {
    ($Trait:ident for $T:ident as $U:ident -> $Radix:ident) => {
@@ -1100,17 +1033,15 @@ macro_rules! int_base {
    }
 }
 "#,
-    );
+    ).assert_expand_items(r#" int_base!{Binary for isize as usize -> Binary}"#,
-    assert_expansion(MacroKind::Items, &rules, r#" int_base!{Binary for isize as usize -> Binary}"#,
        "# [stable (feature = \"rust1\" , since = \"1.0.0\")] impl fmt ::Binary for isize {fn fmt (& self , f : & mut fmt :: Formatter < \'_ >) -> fmt :: Result {Binary . fmt_int (* self as usize , f)}}"
-        );
+    );
 }
 #[test]
 fn test_generate_pattern_iterators() {
    // from https://github.com/rust-lang/rust/blob/316a391dcb7d66dc25f1f9a4ec9d368ef7615005/src/libcore/str/mod.rs
-    let rules = create_rules(
+    parse_macro(
        r#"
 macro_rules! generate_pattern_iterators {
        { double ended; with $(#[$common_stability_attribute:meta])*,
@@ -1121,11 +1052,7 @@ macro_rules! generate_pattern_iterators {
        }
 }
 "#,
-    );
+    ).assert_expand_items(
-    assert_expansion(
-        MacroKind::Items,
-        &rules,
        r#"generate_pattern_iterators ! ( double ended ; with # [ stable ( feature = "rust1" , since = "1.0.0" ) ] , Split , RSplit , & 'a str );"#,
        "fn foo () {}",
    );
@@ -1134,7 +1061,7 @@ macro_rules! generate_pattern_iterators {
 #[test]
 fn test_impl_fn_for_zst() {
    // from https://github.com/rust-lang/rust/blob/5d20ff4d2718c820632b38c1e49d4de648a9810b/src/libcore/internal_macros.rs
-    let rules = create_rules(
+    parse_macro(
        r#"
 macro_rules! impl_fn_for_zst  {
        {  $( $( #[$attr: meta] )*
@@ -1175,9 +1102,7 @@ $body: block; )+
 }
        }
 "#,
-    );
+    ).assert_expand_items(r#"
-    assert_expansion(MacroKind::Items, &rules, r#"
 impl_fn_for_zst !   {
     # [ derive ( Clone ) ]
     struct   CharEscapeDebugContinue   impl   Fn   =   | c :   char |   ->   char :: EscapeDebug   {
@@ -1194,13 +1119,14 @@ impl_fn_for_zst !   {
     } ;
 }
 "#,
-        "# [derive (Clone)] struct CharEscapeDebugContinue ; impl Fn < (char ,) > for CharEscapeDebugContinue {# [inline] extern \"rust-call\" fn call (& self , (c ,) : (char ,)) -> char :: EscapeDebug {{c . escape_debug_ext (false)}}} impl FnMut < (char ,) > for CharEscapeDebugContinue {# [inline] extern \"rust-call\" fn call_mut (& mut self , (c ,) : (char ,)) -> char :: EscapeDebug {Fn :: call (&* self , (c ,))}} impl FnOnce < (char ,) > for CharEscapeDebugContinue {type Output = char :: EscapeDebug ; # [inline] extern \"rust-call\" fn call_once (self , (c ,) : (char ,)) -> char :: EscapeDebug {Fn :: call (& self , (c ,))}} # [derive (Clone)] struct CharEscapeUnicode ; impl Fn < (char ,) > for CharEscapeUnicode {# [inline] extern \"rust-call\" fn call (& self , (c ,) : (char ,)) -> char :: EscapeUnicode {{c . escape_unicode ()}}} impl FnMut < (char ,) > for CharEscapeUnicode {# [inline] extern \"rust-call\" fn call_mut (& mut self , (c ,) : (char ,)) -> char :: EscapeUnicode {Fn :: call (&* self , (c ,))}} impl FnOnce < (char ,) > for CharEscapeUnicode {type Output = char :: EscapeUnicode ; # [inline] extern \"rust-call\" fn call_once (self , (c ,) : (char ,)) -> char :: EscapeUnicode {Fn :: call (& self , (c ,))}} # [derive (Clone)] struct CharEscapeDefault ; impl Fn < (char ,) > for CharEscapeDefault {# [inline] extern \"rust-call\" fn call (& self , (c ,) : (char ,)) -> char :: EscapeDefault {{c . escape_default ()}}} impl FnMut < (char ,) > for CharEscapeDefault {# [inline] extern \"rust-call\" fn call_mut (& mut self , (c ,) : (char ,)) -> char :: EscapeDefault {Fn :: call (&* self , (c ,))}} impl FnOnce < (char ,) > for CharEscapeDefault {type Output = char :: EscapeDefault ; # [inline] extern \"rust-call\" fn call_once (self , (c ,) : (char ,)) -> char :: EscapeDefault {Fn :: call (& self , (c ,))}}");
+        "# [derive (Clone)] struct CharEscapeDebugContinue ; impl Fn < (char ,) > for CharEscapeDebugContinue {# [inline] extern \"rust-call\" fn call (& self , (c ,) : (char ,)) -> char :: EscapeDebug {{c . escape_debug_ext (false)}}} impl FnMut < (char ,) > for CharEscapeDebugContinue {# [inline] extern \"rust-call\" fn call_mut (& mut self , (c ,) : (char ,)) -> char :: EscapeDebug {Fn :: call (&* self , (c ,))}} impl FnOnce < (char ,) > for CharEscapeDebugContinue {type Output = char :: EscapeDebug ; # [inline] extern \"rust-call\" fn call_once (self , (c ,) : (char ,)) -> char :: EscapeDebug {Fn :: call (& self , (c ,))}} # [derive (Clone)] struct CharEscapeUnicode ; impl Fn < (char ,) > for CharEscapeUnicode {# [inline] extern \"rust-call\" fn call (& self , (c ,) : (char ,)) -> char :: EscapeUnicode {{c . escape_unicode ()}}} impl FnMut < (char ,) > for CharEscapeUnicode {# [inline] extern \"rust-call\" fn call_mut (& mut self , (c ,) : (char ,)) -> char :: EscapeUnicode {Fn :: call (&* self , (c ,))}} impl FnOnce < (char ,) > for CharEscapeUnicode {type Output = char :: EscapeUnicode ; # [inline] extern \"rust-call\" fn call_once (self , (c ,) : (char ,)) -> char :: EscapeUnicode {Fn :: call (& self , (c ,))}} # [derive (Clone)] struct CharEscapeDefault ; impl Fn < (char ,) > for CharEscapeDefault {# [inline] extern \"rust-call\" fn call (& self , (c ,) : (char ,)) -> char :: EscapeDefault {{c . escape_default ()}}} impl FnMut < (char ,) > for CharEscapeDefault {# [inline] extern \"rust-call\" fn call_mut (& mut self , (c ,) : (char ,)) -> char :: EscapeDefault {Fn :: call (&* self , (c ,))}} impl FnOnce < (char ,) > for CharEscapeDefault {type Output = char :: EscapeDefault ; # [inline] extern \"rust-call\" fn call_once (self , (c ,) : (char ,)) -> char :: EscapeDefault {Fn :: call (& self , (c ,))}}"
+    );
 }
 #[test]
 fn test_impl_nonzero_fmt() {
    // from https://github.com/rust-lang/rust/blob/316a391dcb7d66dc25f1f9a4ec9d368ef7615005/src/libcore/num/mod.rs#L12
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! impl_nonzero_fmt {
            ( #[$stability: meta] ( $( $Trait: ident ),+ ) for $Ty: ident ) => {
@@ -1208,11 +1134,7 @@ fn test_impl_nonzero_fmt() {
            }
        }
 "#,
-    );
+    ).assert_expand_items(
-    assert_expansion(
-        MacroKind::Items,
-        &rules,
        r#"impl_nonzero_fmt! { # [stable(feature= "nonzero",since="1.28.0")] (Debug,Display,Binary,Octal,LowerHex,UpperHex) for NonZeroU8}"#,
        "fn foo () {}",
    );
@@ -1221,7 +1143,7 @@ fn test_impl_nonzero_fmt() {
 #[test]
 fn test_cfg_if_items() {
    // from https://github.com/rust-lang/rust/blob/33fe1131cadba69d317156847be9a402b89f11bb/src/libstd/macros.rs#L986
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! __cfg_if_items {
            (($($not:meta,)*) ; ) => {};
@@ -1230,11 +1152,7 @@ fn test_cfg_if_items() {
            }
        }
 "#,
-    );
+    ).assert_expand_items(
-    assert_expansion(
-        MacroKind::Items,
-        &rules,
        r#"__cfg_if_items ! { ( rustdoc , ) ; ( ( ) ( # [ cfg ( any ( target_os = "redox" , unix ) ) ] # [ stable ( feature = "rust1" , since = "1.0.0" ) ] pub use sys :: ext as unix ; # [ cfg ( windows ) ] # [ stable ( feature = "rust1" , since = "1.0.0" ) ] pub use sys :: ext as windows ; # [ cfg ( any ( target_os = "linux" , target_os = "l4re" ) ) ] pub mod linux ; ) ) , }"#,
        "__cfg_if_items ! {(rustdoc ,) ;}",
    );
@@ -1243,7 +1161,7 @@ fn test_cfg_if_items() {
 #[test]
 fn test_cfg_if_main() {
    // from https://github.com/rust-lang/rust/blob/3d211248393686e0f73851fc7548f6605220fbe1/src/libpanic_unwind/macros.rs#L9
-    let rules = create_rules(
+    parse_macro(
        r#"
        macro_rules! cfg_if {
            ($(
@@ -1264,9 +1182,7 @@ fn test_cfg_if_main() {
            };
        }
 "#,
-    );
+    ).assert_expand_items(r#"
-    assert_expansion(MacroKind::Items, &rules, r#"
 cfg_if !   {
     if   # [ cfg ( target_env   =   "msvc" ) ]   {
         // no extra unwinder support needed
@@ -1278,11 +1194,8 @@ cfg_if !   {
     }
 }
 "#,
-        "__cfg_if_items ! {() ; ((target_env = \"msvc\") ()) , ((all (target_arch = \"wasm32\" , not (target_os = \"emscripten\"))) ()) , (() (mod libunwind ; pub use libunwind :: * ;)) ,}");
+        "__cfg_if_items ! {() ; ((target_env = \"msvc\") ()) , ((all (target_arch = \"wasm32\" , not (target_os = \"emscripten\"))) ()) , (() (mod libunwind ; pub use libunwind :: * ;)) ,}"
+    ).assert_expand_items(
-    assert_expansion(
-        MacroKind::Items,
-        &rules,
        r#"
 cfg_if ! { @ __apply cfg ( all ( not ( any ( not ( any ( target_os = "solaris" , target_os = "illumos" ) ) ) ) ) ) , }
 "#,
@@ -1293,7 +1206,7 @@ cfg_if ! { @ __apply cfg ( all ( not ( any ( not ( any ( target_os = "solaris" ,
 #[test]
 fn test_proptest_arbitrary() {
    // from https://github.com/AltSysrq/proptest/blob/d1c4b049337d2f75dd6f49a095115f7c532e5129/proptest/src/arbitrary/macros.rs#L16
-    let rules = create_rules(
+    parse_macro(
        r#"
 macro_rules! arbitrary {
    ([$($bounds : tt)*] $typ: ty, $strat: ty, $params: ty;
@@ -1308,22 +1221,21 @@ macro_rules! arbitrary {
    };
 }"#,
-    );
+    ).assert_expand_items(r#"arbitrary !   ( [ A : Arbitrary ]
-    assert_expansion(MacroKind::Items, &rules, r#"arbitrary !   ( [ A : Arbitrary ]
        Vec < A > ,
        VecStrategy < A :: Strategy > ,
        RangedParams1 < A :: Parameters > ;
        args =>   { let product_unpack !   [ range , a ] = args ; vec ( any_with :: < A >   ( a ) , range ) }
    ) ;"#,
-    "impl <A : Arbitrary > $crate :: arbitrary :: Arbitrary for Vec < A > {type Parameters = RangedParams1 < A :: Parameters > ; type Strategy = VecStrategy < A :: Strategy > ; fn arbitrary_with (args : Self :: Parameters) -> Self :: Strategy {{let product_unpack ! [range , a] = args ; vec (any_with :: < A > (a) , range)}}}");
+    "impl <A : Arbitrary > $crate :: arbitrary :: Arbitrary for Vec < A > {type Parameters = RangedParams1 < A :: Parameters > ; type Strategy = VecStrategy < A :: Strategy > ; fn arbitrary_with (args : Self :: Parameters) -> Self :: Strategy {{let product_unpack ! [range , a] = args ; vec (any_with :: < A > (a) , range)}}}"
+    );
 }
 #[test]
 fn test_old_ridl() {
    // This is from winapi 2.8, which do not have a link from github
    //
-    let rules = create_rules(
+    let expanded = parse_macro(
        r#"
 #[macro_export]
 macro_rules! RIDL {
@@ -1339,21 +1251,17 @@ macro_rules! RIDL {
        }
    };
 }"#,
-    );
+    ).expand_tt(r#"
+    RIDL!{interface ID3D11Asynchronous(ID3D11AsynchronousVtbl): ID3D11DeviceChild(ID3D11DeviceChildVtbl) {
+        fn GetDataSize(&mut self) -> UINT
+    }}"#);
-    let expanded = expand(
-        &rules,
-        r#"
-RIDL!{interface ID3D11Asynchronous(ID3D11AsynchronousVtbl): ID3D11DeviceChild(ID3D11DeviceChildVtbl) {
-    fn GetDataSize(&mut self) -> UINT
-}}"#,
-    );
    assert_eq!(expanded.to_string(), "impl ID3D11Asynchronous {pub unsafe fn GetDataSize (& mut self) -> UINT {((* self . lpVtbl) .GetDataSize) (self)}}");
 }
 #[test]
 fn test_quick_error() {
-    let rules = create_rules(
+    let expanded = parse_macro(
        r#"
 macro_rules! quick_error {
@@ -1376,10 +1284,8 @@ macro_rules! quick_error {
 }
 "#,
-    );
+    )
+    .expand_tt(
-    let expanded = expand(
-        &rules,
        r#"
 quick_error ! (SORT [enum Wrapped # [derive (Debug)]] items [
        => One : UNIT [] {}
@@ -1393,7 +1299,7 @@ quick_error ! (SORT [enum Wrapped # [derive (Debug)]] items [
 #[test]
 fn test_empty_repeat_vars_in_empty_repeat_vars() {
-    let rules = create_rules(
+    parse_macro(
        r#"
 macro_rules! delegate_impl {
    ([$self_type:ident, $self_wrap:ty, $self_map:ident]
@@ -1440,120 +1346,117 @@ macro_rules! delegate_impl {
    }
 }
 "#,
-    );
+    ).assert_expand_items(
-    assert_expansion(
-        MacroKind::Items,
-        &rules,
        r#"delegate_impl ! {[G , & 'a mut G , deref] pub trait Data : GraphBase {@ section type type NodeWeight ;}}"#,
        "impl <> Data for & \'a mut G where G : Data {}",
    );
 }
-pub(crate) fn create_rules(macro_definition: &str) -> MacroRules {
+#[test]
-    let source_file = ast::SourceFile::parse(macro_definition).ok().unwrap();
+fn expr_interpolation() {
-    let macro_definition =
+    let expanded = parse_macro(
-        source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
+        r#"
+        macro_rules! id {
+            ($expr:expr) => {
+                map($expr)
+            }
+        }
+        "#,
+    )
+    .expand_expr("id!(x + foo);");
-    let (definition_tt, _) = ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
+    assert_eq!(expanded.to_string(), "map(x+foo)");
-    crate::MacroRules::parse(&definition_tt).unwrap()
 }
-pub(crate) fn expand(rules: &MacroRules, invocation: &str) -> tt::Subtree {
+pub(crate) struct MacroFixture {
-    let source_file = ast::SourceFile::parse(invocation).ok().unwrap();
+    rules: MacroRules,
-    let macro_invocation =
+}
-        source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-    let (invocation_tt, _) = ast_to_token_tree(&macro_invocation.token_tree().unwrap()).unwrap();
+impl MacroFixture {
+    pub(crate) fn expand_tt(&self, invocation: &str) -> tt::Subtree {
+        let source_file = ast::SourceFile::parse(invocation).ok().unwrap();
+        let macro_invocation =
+            source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-    rules.expand(&invocation_tt).unwrap()
+        let (invocation_tt, _) =
-}
+            ast_to_token_tree(&macro_invocation.token_tree().unwrap()).unwrap();
-pub(crate) fn expand_and_map(
+        self.rules.expand(&invocation_tt).unwrap()
-    rules: &MacroRules,
+    }
-    invocation: &str,
-) -> (tt::Subtree, (TokenMap, String)) {
-    let source_file = ast::SourceFile::parse(invocation).ok().unwrap();
-    let macro_invocation =
-        source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-    let (invocation_tt, _) = ast_to_token_tree(&macro_invocation.token_tree().unwrap()).unwrap();
+    fn expand_items(&self, invocation: &str) -> SyntaxNode {
-    let expanded = rules.expand(&invocation_tt).unwrap();
+        let expanded = self.expand_tt(invocation);
+        token_tree_to_syntax_node(&expanded, FragmentKind::Items).unwrap().0.syntax_node()
+    }
-    let (node, expanded_token_tree) =
+    fn expand_statements(&self, invocation: &str) -> SyntaxNode {
-        token_tree_to_syntax_node(&expanded, FragmentKind::Items).unwrap();
+        let expanded = self.expand_tt(invocation);
+        token_tree_to_syntax_node(&expanded, FragmentKind::Statements).unwrap().0.syntax_node()
+    }
-    (expanded, (expanded_token_tree, node.syntax_node().to_string()))
+    fn expand_expr(&self, invocation: &str) -> SyntaxNode {
-}
+        let expanded = self.expand_tt(invocation);
+        token_tree_to_syntax_node(&expanded, FragmentKind::Expr).unwrap().0.syntax_node()
+    }
-pub(crate) enum MacroKind {
+    fn assert_expand_tt(&self, invocation: &str, expected: &str) {
-    Items,
+        let expansion = self.expand_tt(invocation);
-    Stmts,
+        assert_eq!(expansion.to_string(), expected);
-}
+    }
-pub(crate) fn assert_expansion(
+    fn assert_expand_items(&self, invocation: &str, expected: &str) -> &MacroFixture {
-    kind: MacroKind,
+        self.assert_expansion(FragmentKind::Items, invocation, expected);
-    rules: &MacroRules,
+        self
-    invocation: &str,
+    }
-    expected: &str,
-) -> tt::Subtree {
-    let expanded = expand(rules, invocation);
-    assert_eq!(expanded.to_string(), expected);
-    let expected = expected.replace("$crate", "C_C__C");
+    fn assert_expand_statements(&self, invocation: &str, expected: &str) -> &MacroFixture {
+        self.assert_expansion(FragmentKind::Statements, invocation, expected);
+        self
+    }
-    // wrap the given text to a macro call
+    fn assert_expansion(&self, kind: FragmentKind, invocation: &str, expected: &str) {
-    let expected = {
+        let expanded = self.expand_tt(invocation);
-        let wrapped = format!("wrap_macro!( {} )", expected);
+        assert_eq!(expanded.to_string(), expected);
-        let wrapped = ast::SourceFile::parse(&wrapped);
-        let wrapped = wrapped.tree().syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
+        let expected = expected.replace("$crate", "C_C__C");
-        let mut wrapped = ast_to_token_tree(&wrapped).unwrap().0;
-        wrapped.delimiter = None;
+        // wrap the given text to a macro call
-        wrapped
+        let expected = {
-    };
+            let wrapped = format!("wrap_macro!( {} )", expected);
-    let (expanded_tree, expected_tree) = match kind {
+            let wrapped = ast::SourceFile::parse(&wrapped);
-        MacroKind::Items => {
+            let wrapped =
-            let expanded_tree =
+                wrapped.tree().syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
-                token_tree_to_syntax_node(&expanded, FragmentKind::Items).unwrap().0.syntax_node();
+            let mut wrapped = ast_to_token_tree(&wrapped).unwrap().0;
-            let expected_tree =
+            wrapped.delimiter = None;
-                token_tree_to_syntax_node(&expected, FragmentKind::Items).unwrap().0.syntax_node();
+            wrapped
+        };
-            (
-                debug_dump_ignore_spaces(&expanded_tree).trim().to_string(),
-                debug_dump_ignore_spaces(&expected_tree).trim().to_string(),
-            )
-        }
-        MacroKind::Stmts => {
+        let expanded_tree = token_tree_to_syntax_node(&expanded, kind).unwrap().0.syntax_node();
-            let expanded_tree = token_tree_to_syntax_node(&expanded, FragmentKind::Statements)
+        let expanded_tree = debug_dump_ignore_spaces(&expanded_tree).trim().to_string();
-                .unwrap()
-                .0
-                .syntax_node();
-            let expected_tree = token_tree_to_syntax_node(&expected, FragmentKind::Statements)
-                .unwrap()
-                .0
-                .syntax_node();
-            (
-                debug_dump_ignore_spaces(&expanded_tree).trim().to_string(),
-                debug_dump_ignore_spaces(&expected_tree).trim().to_string(),
-            )
-        }
-    };
-    let expected_tree = expected_tree.replace("C_C__C", "$crate");
+        let expected_tree = token_tree_to_syntax_node(&expected, kind).unwrap().0.syntax_node();
-    assert_eq!(
+        let expected_tree = debug_dump_ignore_spaces(&expected_tree).trim().to_string();
-        expanded_tree, expected_tree,
-        "\nleft:\n{}\nright:\n{}",
-        expanded_tree, expected_tree,
-    );
-    expanded
+        let expected_tree = expected_tree.replace("C_C__C", "$crate");
+        assert_eq!(
+            expanded_tree, expected_tree,
+            "\nleft:\n{}\nright:\n{}",
+            expanded_tree, expected_tree,
+        );
+    }
 }
-pub fn debug_dump_ignore_spaces(node: &ra_syntax::SyntaxNode) -> String {
+pub(crate) fn parse_macro(macro_definition: &str) -> MacroFixture {
-    use std::fmt::Write;
+    let source_file = ast::SourceFile::parse(macro_definition).ok().unwrap();
+    let macro_definition =
+        source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
+    let (definition_tt, _) = ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
+    let rules = MacroRules::parse(&definition_tt).unwrap();
+    MacroFixture { rules }
+}
+fn debug_dump_ignore_spaces(node: &ra_syntax::SyntaxNode) -> String {
    let mut level = 0;
    let mut buf = String::new();
    macro_rules! indent {
diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs
index 6e9e212b7..22f64a9f4 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -264,7 +264,7 @@ fn name_r(p: &mut Parser, recovery: TokenSet) {
 }
 fn name(p: &mut Parser) {
-    name_r(p, TokenSet::empty())
+    name_r(p, TokenSet::EMPTY)
 }
 fn name_ref(p: &mut Parser) {
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index 09f0a2d98..4ac1d6334 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -43,6 +43,7 @@ pub(super) const ATOM_EXPR_FIRST: TokenSet =
        T!['('],
        T!['{'],
        T!['['],
+        L_DOLLAR,
        T![|],
        T![move],
        T![box],
@@ -443,7 +444,7 @@ fn match_arm(p: &mut Parser) -> BlockLike {
    // }
    attributes::outer_attributes(p);
-    patterns::pattern_list_r(p, TokenSet::empty());
+    patterns::pattern_list_r(p, TokenSet::EMPTY);
    if p.at(T![if]) {
        match_guard(p);
    }
diff --git a/crates/ra_parser/src/lib.rs b/crates/ra_parser/src/lib.rs
index 45241e566..65134277e 100644
--- a/crates/ra_parser/src/lib.rs
+++ b/crates/ra_parser/src/lib.rs
@@ -83,6 +83,7 @@ pub fn parse(token_source: &mut dyn TokenSource, tree_sink: &mut dyn TreeSink) {
    parse_from_tokens(token_source, tree_sink, grammar::root);
 }
+#[derive(Clone, Copy)]
 pub enum FragmentKind {
    Path,
    Expr,
diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs
index dafd5247b..1071c46dc 100644
--- a/crates/ra_parser/src/parser.rs
+++ b/crates/ra_parser/src/parser.rs
@@ -208,7 +208,7 @@ impl<'t> Parser<'t> {
    /// Create an error node and consume the next token.
    pub(crate) fn err_and_bump(&mut self, message: &str) {
-        self.err_recover(message, TokenSet::empty());
+        self.err_recover(message, TokenSet::EMPTY);
    }
    /// Create an error node and consume the next token.
diff --git a/crates/ra_parser/src/token_set.rs b/crates/ra_parser/src/token_set.rs
index 2a6952c01..994017acf 100644
--- a/crates/ra_parser/src/token_set.rs
+++ b/crates/ra_parser/src/token_set.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! A bit-set of `SyntaxKind`s.
 use crate::SyntaxKind;
@@ -7,9 +7,7 @@ use crate::SyntaxKind;
 pub(crate) struct TokenSet(u128);
 impl TokenSet {
-    pub(crate) const fn empty() -> TokenSet {
+    pub(crate) const EMPTY: TokenSet = TokenSet(0);
-        TokenSet(0)
-    }
    pub(crate) const fn singleton(kind: SyntaxKind) -> TokenSet {
        TokenSet(mask(kind))
@@ -30,7 +28,7 @@ const fn mask(kind: SyntaxKind) -> u128 {
 #[macro_export]
 macro_rules! token_set {
-    ($($t:expr),*) => { TokenSet::empty()$(.union(TokenSet::singleton($t)))* };
+    ($($t:expr),*) => { TokenSet::EMPTY$(.union(TokenSet::singleton($t)))* };
    ($($t:expr),* ,) => { token_set!($($t),*) };
 }
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index 657ddf2a6..659f77b71 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -207,8 +207,8 @@ pub fn lines_match(expected: &str, actual: &str) -> bool {
    // Let's not deal with / vs \ (windows...)
    // First replace backslash-escaped backslashes with forward slashes
    // which can occur in, for example, JSON output
-    let expected = expected.replace("\\\\", "/").replace("\\", "/");
+    let expected = expected.replace(r"\\", "/").replace(r"\", "/");
-    let mut actual: &str = &actual.replace("\\\\", "/").replace("\\", "/");
+    let mut actual: &str = &actual.replace(r"\\", "/").replace(r"\", "/");
    for (i, part) in expected.split("[..]").enumerate() {
        match actual.find(part) {
            Some(j) => {