46 files changed, 670 insertions, 505 deletions
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 1908bdec9..0ea84d548 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -1,6 +1,5 @@
 //! This module defines `AssistCtx` -- the API surface that is exposed to assists.
+use hir::{db::HirDatabase, SourceAnalyzer};
-use hir::db::HirDatabase;
 use ra_db::FileRange;
 use ra_fmt::{leading_indent, reindent};
 use ra_syntax::{
@@ -113,6 +112,13 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
    pub(crate) fn covering_element(&self) -> SyntaxElement {
        find_covering_element(self.source_file.syntax(), self.frange.range)
    }
+    pub(crate) fn source_analyzer(
+        &self,
+        node: &SyntaxNode,
+        offset: Option<TextUnit>,
+    ) -> SourceAnalyzer {
+        SourceAnalyzer::new(self.db, hir::Source::new(self.frange.file_id.into(), node), offset)
+    }
    pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement {
        find_covering_element(self.source_file.syntax(), range)
diff --git a/crates/ra_assists/src/assists/add_explicit_type.rs b/crates/ra_assists/src/assists/add_explicit_type.rs
index ddda1a0f2..562a09685 100644
--- a/crates/ra_assists/src/assists/add_explicit_type.rs
+++ b/crates/ra_assists/src/assists/add_explicit_type.rs
@@ -40,7 +40,7 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
    }
    // Infer type
    let db = ctx.db;
-    let analyzer = hir::SourceAnalyzer::new(db, ctx.frange.file_id, stmt.syntax(), None);
+    let analyzer = ctx.source_analyzer(stmt.syntax(), None);
    let ty = analyzer.type_of(db, &expr)?;
    // Assist not applicable if the type is unknown
    if is_unknown(&ty) {
diff --git a/crates/ra_assists/src/assists/add_missing_impl_members.rs b/crates/ra_assists/src/assists/add_missing_impl_members.rs
index 41de23921..91af161ee 100644
--- a/crates/ra_assists/src/assists/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/assists/add_missing_impl_members.rs
@@ -100,8 +100,7 @@ fn add_missing_impl_members_inner(
    let impl_item_list = impl_node.item_list()?;
    let trait_def = {
-        let file_id = ctx.frange.file_id;
+        let analyzer = ctx.source_analyzer(impl_node.syntax(), None);
-        let analyzer = hir::SourceAnalyzer::new(ctx.db, file_id, impl_node.syntax(), None);
        resolve_target_trait_def(ctx.db, &analyzer, &impl_node)?
    };
diff --git a/crates/ra_assists/src/assists/add_new.rs b/crates/ra_assists/src/assists/add_new.rs
index a8839cfba..2038afdc6 100644
--- a/crates/ra_assists/src/assists/add_new.rs
+++ b/crates/ra_assists/src/assists/add_new.rs
@@ -158,9 +158,12 @@ fn find_struct_impl(
        let same_ty = blk.target_ty(db) == struct_ty;
        let not_trait_impl = blk.target_trait(db).is_none();
-        found_new_fn = has_new_fn(impl_blk);
+        if !(same_ty && not_trait_impl) {
+            return false;
+        }
-        same_ty && not_trait_impl
+        found_new_fn = has_new_fn(impl_blk);
+        true
    });
    if found_new_fn {
@@ -186,9 +189,10 @@ fn has_new_fn(imp: &ast::ImplBlock) -> bool {
 #[cfg(test)]
 mod tests {
-    use super::*;
    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    use super::*;
    #[test]
    #[rustfmt::skip]
    fn test_add_new() {
@@ -345,7 +349,7 @@ struct Foo {<|>}
 impl Foo {
    fn new() -> Self {
        Self
-    }    
+    }
 }",
        );
@@ -357,7 +361,7 @@ struct Foo {<|>}
 impl Foo {
    fn New() -> Self {
        Self
-    }    
+    }
 }",
        );
    }
@@ -376,4 +380,59 @@ struct EvenMoreIrrelevant;
 struct Foo<'a, T: Foo<'a>> {}",
        );
    }
+    #[test]
+    fn test_unrelated_new() {
+        check_assist(
+            add_new,
+            r##"
+pub struct AstId<N: AstNode> {
+    file_id: HirFileId,
+    file_ast_id: FileAstId<N>,
+}
+impl<N: AstNode> AstId<N> {
+    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
+        AstId { file_id, file_ast_id }
+    }
+}
+pub struct Source<T> {
+    pub file_id: HirFileId,<|>
+    pub ast: T,
+}
+impl<T> Source<T> {
+    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
+        Source { file_id: self.file_id, ast: f(self.ast) }
+    }
+}
+"##,
+            r##"
+pub struct AstId<N: AstNode> {
+    file_id: HirFileId,
+    file_ast_id: FileAstId<N>,
+}
+impl<N: AstNode> AstId<N> {
+    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
+        AstId { file_id, file_ast_id }
+    }
+}
+pub struct Source<T> {
+    pub file_id: HirFileId,
+    pub ast: T,
+}
+impl<T> Source<T> {
+    pub fn new(file_id: HirFileId, ast: T) -> Self { Self { file_id, ast } }<|>
+    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
+        Source { file_id: self.file_id, ast: f(self.ast) }
+    }
+}
+"##,
+        );
+    }
 }
diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/assists/fill_match_arms.rs
index 2b74f355c..b851c2082 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/assists/fill_match_arms.rs
@@ -47,8 +47,7 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
    let expr = match_expr.expr()?;
    let enum_def = {
-        let file_id = ctx.frange.file_id;
+        let analyzer = ctx.source_analyzer(expr.syntax(), None);
-        let analyzer = hir::SourceAnalyzer::new(ctx.db, file_id, expr.syntax(), None);
        resolve_enum_def(ctx.db, &analyzer, &expr)?
    };
    let variant_list = enum_def.variant_list()?;
diff --git a/crates/ra_assists/src/assists/inline_local_variable.rs b/crates/ra_assists/src/assists/inline_local_variable.rs
index a7fd9b6d2..18a34502c 100644
--- a/crates/ra_assists/src/assists/inline_local_variable.rs
+++ b/crates/ra_assists/src/assists/inline_local_variable.rs
@@ -45,7 +45,7 @@ pub(crate) fn inline_local_varialbe(ctx: AssistCtx<impl HirDatabase>) -> Option<
    } else {
        let_stmt.syntax().text_range()
    };
-    let analyzer = hir::SourceAnalyzer::new(ctx.db, ctx.frange.file_id, bind_pat.syntax(), None);
+    let analyzer = ctx.source_analyzer(bind_pat.syntax(), None);
    let refs = analyzer.find_all_refs(&bind_pat);
    let mut wrap_in_parens = vec![true; refs.len()];
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 078bd8609..731cc1fff 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -11,7 +11,7 @@ use hir_def::{
    body::scope::ExprScopes,
    builtin_type::BuiltinType,
    type_ref::{Mutability, TypeRef},
-    CrateModuleId, LocalEnumVariantId, LocalStructFieldId, ModuleId, UnionId,
+    CrateModuleId, ImplId, LocalEnumVariantId, LocalStructFieldId, ModuleId, UnionId,
 };
 use hir_expand::{
    diagnostics::DiagnosticSink,
@@ -29,7 +29,6 @@ use crate::{
        AstItemDef, ConstId, EnumId, FunctionId, MacroDefId, StaticId, StructId, TraitId,
        TypeAliasId,
    },
-    impl_block::ImplBlock,
    resolve::{Resolver, Scope, TypeNs},
    traits::TraitData,
    ty::{InferenceResult, Namespace, TraitRef},
@@ -243,12 +242,8 @@ impl Module {
    }
    pub fn impl_blocks(self, db: &impl DefDatabase) -> Vec<ImplBlock> {
-        let module_impl_blocks = db.impls_in_module(self);
+        let def_map = db.crate_def_map(self.id.krate);
-        module_impl_blocks
+        def_map[self.id.module_id].impls.iter().copied().map(ImplBlock::from).collect()
-            .impls
-            .iter()
-            .map(|(impl_id, _)| ImplBlock::from_id(self, impl_id))
-            .collect()
    }
    fn with_module_id(self, module_id: CrateModuleId) -> Module {
@@ -693,8 +688,7 @@ impl Function {
    /// The containing impl block, if this is a method.
    pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        let module_impls = db.impls_in_module(self.module(db));
+        ImplBlock::containing(db, self.into())
-        ImplBlock::containing(module_impls, self.into())
    }
    /// The containing trait, if this is a trait method definition.
@@ -759,8 +753,7 @@ impl Const {
    /// The containing impl block, if this is a method.
    pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        let module_impls = db.impls_in_module(self.module(db));
+        ImplBlock::containing(db, self.into())
-        ImplBlock::containing(module_impls, self.into())
    }
    pub fn parent_trait(self, db: &impl DefDatabase) -> Option<Trait> {
@@ -973,8 +966,7 @@ impl TypeAlias {
    /// The containing impl block, if this is a method.
    pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        let module_impls = db.impls_in_module(self.module(db));
+        ImplBlock::containing(db, self.into())
-        ImplBlock::containing(module_impls, self.into())
    }
    /// The containing trait, if this is a trait method definition.
@@ -1137,3 +1129,8 @@ pub struct GenericParam {
    pub(crate) parent: GenericDef,
    pub(crate) idx: u32,
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ImplBlock {
+    pub(crate) id: ImplId,
+}
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index c60029c01..276b0774f 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -10,7 +10,6 @@ use crate::{
    debug::HirDebugDatabase,
    generics::{GenericDef, GenericParams},
    ids,
-    impl_block::{ImplBlock, ImplSourceMap, ModuleImplBlocks},
    lang_item::{LangItemTarget, LangItems},
    traits::TraitData,
    ty::{
@@ -18,14 +17,14 @@ use crate::{
        InferenceResult, Namespace, Substs, Ty, TypableDef, TypeCtor,
    },
    type_alias::TypeAliasData,
-    Const, ConstData, Crate, DefWithBody, FnData, Function, Module, Static, StructField, Trait,
+    Const, ConstData, Crate, DefWithBody, FnData, Function, ImplBlock, Module, Static, StructField,
-    TypeAlias,
+    Trait, TypeAlias,
 };
 pub use hir_def::db::{
    BodyQuery, BodyWithSourceMapQuery, CrateDefMapQuery, DefDatabase2, DefDatabase2Storage,
-    EnumDataQuery, ExprScopesQuery, InternDatabase, InternDatabaseStorage, RawItemsQuery,
+    EnumDataQuery, ExprScopesQuery, ImplDataQuery, InternDatabase, InternDatabaseStorage,
-    RawItemsWithSourceMapQuery, StructDataQuery,
+    RawItemsQuery, RawItemsWithSourceMapQuery, StructDataQuery,
 };
 pub use hir_expand::db::{
    AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
@@ -42,15 +41,6 @@ pub trait DefDatabase: HirDebugDatabase + DefDatabase2 {
    #[salsa::invoke(crate::traits::TraitItemsIndex::trait_items_index)]
    fn trait_items_index(&self, module: Module) -> crate::traits::TraitItemsIndex;
-    #[salsa::invoke(ModuleImplBlocks::impls_in_module_with_source_map_query)]
-    fn impls_in_module_with_source_map(
-        &self,
-        module: Module,
-    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>);
-    #[salsa::invoke(ModuleImplBlocks::impls_in_module_query)]
-    fn impls_in_module(&self, module: Module) -> Arc<ModuleImplBlocks>;
    #[salsa::invoke(crate::generics::GenericParams::generic_params_query)]
    fn generic_params(&self, def: GenericDef) -> Arc<GenericParams>;
@@ -128,7 +118,7 @@ pub trait HirDatabase: DefDatabase + AstDatabase {
    #[salsa::interned]
    fn intern_type_ctor(&self, type_ctor: TypeCtor) -> ids::TypeCtorId;
    #[salsa::interned]
-    fn intern_impl(&self, impl_: Impl) -> ids::GlobalImplId;
+    fn intern_chalk_impl(&self, impl_: Impl) -> ids::GlobalImplId;
    #[salsa::invoke(crate::ty::traits::chalk::associated_ty_data_query)]
    fn associated_ty_data(&self, id: chalk_ir::TypeId) -> Arc<chalk_rust_ir::AssociatedTyDatum>;
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index 9633ef586..f2203e995 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -3,9 +3,9 @@
 //! It's unclear if we need this long-term, but it's definitelly useful while we
 //! are splitting the hir.
-use hir_def::{AdtId, DefWithBodyId, EnumVariantId, ModuleDefId};
+use hir_def::{AdtId, AssocItemId, DefWithBodyId, EnumVariantId, ModuleDefId};
-use crate::{Adt, DefWithBody, EnumVariant, ModuleDef};
+use crate::{Adt, AssocItem, DefWithBody, EnumVariant, ModuleDef};
 macro_rules! from_id {
    ($(($id:path, $ty:path)),*) => {$(
@@ -27,6 +27,7 @@ from_id![
    (hir_def::StaticId, crate::Static),
    (hir_def::ConstId, crate::Const),
    (hir_def::FunctionId, crate::Function),
+    (hir_def::ImplId, crate::ImplBlock),
    (hir_expand::MacroDefId, crate::MacroDef)
 ];
@@ -71,3 +72,13 @@ impl From<DefWithBody> for DefWithBodyId {
        }
    }
 }
+impl From<AssocItemId> for AssocItem {
+    fn from(def: AssocItemId) -> Self {
+        match def {
+            AssocItemId::FunctionId(it) => AssocItem::Function(it.into()),
+            AssocItemId::TypeAliasId(it) => AssocItem::TypeAlias(it.into()),
+            AssocItemId::ConstId(it) => AssocItem::Const(it.into()),
+        }
+    }
+}
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index 7e5523c54..1c26756c9 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 use hir_def::{ModuleId, StructId, StructOrUnionId, UnionId};
-use hir_expand::name::AsName;
+use hir_expand::{name::AsName, AstId, MacroDefId, MacroDefKind};
 use ra_syntax::{
    ast::{self, AstNode, NameOwner},
    match_ast,
@@ -11,8 +11,8 @@ use crate::{
    db::{AstDatabase, DefDatabase, HirDatabase},
    ids::{AstItemDef, LocationCtx},
    Const, DefWithBody, Enum, EnumVariant, FieldSource, Function, HasBody, HasSource, ImplBlock,
-    Local, Module, ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias, Union,
+    Local, MacroDef, Module, ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias,
-    VariantDef,
+    Union, VariantDef,
 };
 pub trait FromSource: Sized {
@@ -77,19 +77,28 @@ impl FromSource for TypeAlias {
        Some(TypeAlias { id })
    }
 }
-// FIXME: add impl FromSource for MacroDef
+impl FromSource for MacroDef {
+    type Ast = ast::MacroCall;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let kind = MacroDefKind::Declarative;
+        let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
+        let module = Module::from_definition(db, Source::new(src.file_id, module_src))?;
+        let krate = module.krate().crate_id();
+        let ast_id = AstId::new(src.file_id, db.ast_id_map(src.file_id).ast_id(&src.ast));
+        let id: MacroDefId = MacroDefId { krate, ast_id, kind };
+        Some(MacroDef { id })
+    }
+}
 impl FromSource for ImplBlock {
    type Ast = ast::ImplBlock;
    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
-        let module_src = crate::ModuleSource::from_child_node(
+        let id = from_source(db, src)?;
-            db,
+        Some(ImplBlock { id })
-            src.file_id.original_file(db),
-            &src.ast.syntax(),
-        );
-        let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
-        let impls = module.impl_blocks(db);
-        impls.into_iter().find(|b| b.source(db) == src)
    }
 }
@@ -202,9 +211,8 @@ where
    N: AstNode,
    DEF: AstItemDef<N>,
 {
-    let module_src =
+    let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
-        crate::ModuleSource::from_child_node(db, src.file_id.original_file(db), &src.ast.syntax());
+    let module = Module::from_definition(db, Source::new(src.file_id, module_src))?;
-    let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
    let ctx = LocationCtx::new(db, module.id, src.file_id);
    Some(DEF::from_ast(ctx, &src.ast))
 }
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index b1a014074..0c2bb8fee 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -1,88 +1,38 @@
 //! FIXME: write short doc here
-use rustc_hash::FxHashMap;
+use hir_def::{type_ref::TypeRef, AstItemDef};
-use std::sync::Arc;
+use ra_syntax::ast::{self};
-use hir_def::{attr::Attr, type_ref::TypeRef};
-use hir_expand::hygiene::Hygiene;
-use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
-use ra_cfg::CfgOptions;
-use ra_syntax::{
-    ast::{self, AstNode},
-    AstPtr,
-};
 use crate::{
-    code_model::{Module, ModuleSource},
    db::{AstDatabase, DefDatabase, HirDatabase},
    generics::HasGenericParams,
-    ids::LocationCtx,
-    ids::MacroCallLoc,
    resolve::Resolver,
    ty::Ty,
-    AssocItem, AstId, Const, Function, HasSource, HirFileId, MacroFileKind, Path, Source, TraitRef,
+    AssocItem, Crate, HasSource, ImplBlock, Module, Source, TraitRef,
-    TypeAlias,
 };
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct ImplSourceMap {
-    map: ArenaMap<ImplId, Source<AstPtr<ast::ImplBlock>>>,
-}
-impl ImplSourceMap {
-    fn insert(&mut self, impl_id: ImplId, file_id: HirFileId, impl_block: &ast::ImplBlock) {
-        let source = Source { file_id, ast: AstPtr::new(impl_block) };
-        self.map.insert(impl_id, source)
-    }
-    pub fn get(&self, db: &impl AstDatabase, impl_id: ImplId) -> Source<ast::ImplBlock> {
-        let src = self.map[impl_id];
-        let root = src.file_syntax(db);
-        src.map(|ptr| ptr.to_node(&root))
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ImplBlock {
-    module: Module,
-    impl_id: ImplId,
-}
 impl HasSource for ImplBlock {
    type Ast = ast::ImplBlock;
    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::ImplBlock> {
-        let source_map = db.impls_in_module_with_source_map(self.module).1;
+        self.id.source(db)
-        source_map.get(db, self.impl_id)
    }
 }
 impl ImplBlock {
-    pub(crate) fn containing(
+    pub(crate) fn containing(db: &impl DefDatabase, item: AssocItem) -> Option<ImplBlock> {
-        module_impl_blocks: Arc<ModuleImplBlocks>,
+        let module = item.module(db);
-        item: AssocItem,
+        let crate_def_map = db.crate_def_map(module.id.krate);
-    ) -> Option<ImplBlock> {
+        crate_def_map[module.id.module_id].impls.iter().copied().map(ImplBlock::from).find(|it| {
-        let impl_id = *module_impl_blocks.impls_by_def.get(&item)?;
+            db.impl_data(it.id).items().iter().copied().map(AssocItem::from).any(|it| it == item)
-        Some(ImplBlock { module: module_impl_blocks.module, impl_id })
+        })
-    }
-    pub(crate) fn from_id(module: Module, impl_id: ImplId) -> ImplBlock {
-        ImplBlock { module, impl_id }
-    }
-    pub fn id(&self) -> ImplId {
-        self.impl_id
-    }
-    pub fn module(&self) -> Module {
-        self.module
    }
    pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
-        db.impls_in_module(self.module).impls[self.impl_id].target_trait().cloned()
+        db.impl_data(self.id).target_trait().cloned()
    }
    pub fn target_type(&self, db: &impl DefDatabase) -> TypeRef {
-        db.impls_in_module(self.module).impls[self.impl_id].target_type().clone()
+        db.impl_data(self.id).target_type().clone()
    }
    pub fn target_ty(&self, db: &impl HirDatabase) -> Ty {
@@ -95,15 +45,23 @@ impl ImplBlock {
    }
    pub fn items(&self, db: &impl DefDatabase) -> Vec<AssocItem> {
-        db.impls_in_module(self.module).impls[self.impl_id].items().to_vec()
+        db.impl_data(self.id).items().iter().map(|it| (*it).into()).collect()
    }
    pub fn is_negative(&self, db: &impl DefDatabase) -> bool {
-        db.impls_in_module(self.module).impls[self.impl_id].negative
+        db.impl_data(self.id).is_negative()
+    }
+    pub fn module(&self, db: &impl DefDatabase) -> Module {
+        self.id.module(db).into()
+    }
+    pub fn krate(&self, db: &impl DefDatabase) -> Crate {
+        Crate { crate_id: self.module(db).id.krate }
    }
    pub(crate) fn resolver(&self, db: &impl DefDatabase) -> Resolver {
-        let r = self.module().resolver(db);
+        let r = self.module(db).resolver(db);
        // add generic params, if present
        let p = self.generic_params(db);
        let r = if !p.params.is_empty() { r.push_generic_params_scope(p) } else { r };
@@ -111,175 +69,3 @@ impl ImplBlock {
        r
    }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ImplData {
-    target_trait: Option<TypeRef>,
-    target_type: TypeRef,
-    items: Vec<AssocItem>,
-    negative: bool,
-}
-impl ImplData {
-    pub(crate) fn from_ast(
-        db: &(impl DefDatabase + AstDatabase),
-        file_id: HirFileId,
-        module: Module,
-        node: &ast::ImplBlock,
-    ) -> Self {
-        let target_trait = node.target_trait().map(TypeRef::from_ast);
-        let target_type = TypeRef::from_ast_opt(node.target_type());
-        let ctx = LocationCtx::new(db, module.id, file_id);
-        let negative = node.is_negative();
-        let items = if let Some(item_list) = node.item_list() {
-            item_list
-                .impl_items()
-                .map(|item_node| match item_node {
-                    ast::ImplItem::FnDef(it) => Function { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItem::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItem::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(),
-                })
-                .collect()
-        } else {
-            Vec::new()
-        };
-        ImplData { target_trait, target_type, items, negative }
-    }
-    pub fn target_trait(&self) -> Option<&TypeRef> {
-        self.target_trait.as_ref()
-    }
-    pub fn target_type(&self) -> &TypeRef {
-        &self.target_type
-    }
-    pub fn items(&self) -> &[AssocItem] {
-        &self.items
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ImplId(pub RawId);
-impl_arena_id!(ImplId);
-/// The collection of impl blocks is a two-step process: first we collect the
-/// blocks per-module; then we build an index of all impl blocks in the crate.
-/// This way, we avoid having to do this process for the whole crate whenever
-/// a file is changed; as long as the impl blocks in the file don't change,
-/// we don't need to do the second step again.
-#[derive(Debug, PartialEq, Eq)]
-pub struct ModuleImplBlocks {
-    pub(crate) module: Module,
-    pub(crate) impls: Arena<ImplId, ImplData>,
-    impls_by_def: FxHashMap<AssocItem, ImplId>,
-}
-impl ModuleImplBlocks {
-    pub(crate) fn impls_in_module_with_source_map_query(
-        db: &(impl DefDatabase + AstDatabase),
-        module: Module,
-    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>) {
-        let mut source_map = ImplSourceMap::default();
-        let crate_graph = db.crate_graph();
-        let cfg_options = crate_graph.cfg_options(module.id.krate);
-        let result = ModuleImplBlocks::collect(db, cfg_options, module, &mut source_map);
-        (Arc::new(result), Arc::new(source_map))
-    }
-    pub(crate) fn impls_in_module_query(
-        db: &impl DefDatabase,
-        module: Module,
-    ) -> Arc<ModuleImplBlocks> {
-        db.impls_in_module_with_source_map(module).0
-    }
-    fn collect(
-        db: &(impl DefDatabase + AstDatabase),
-        cfg_options: &CfgOptions,
-        module: Module,
-        source_map: &mut ImplSourceMap,
-    ) -> Self {
-        let mut m = ModuleImplBlocks {
-            module,
-            impls: Arena::default(),
-            impls_by_def: FxHashMap::default(),
-        };
-        let src = m.module.definition_source(db);
-        match &src.ast {
-            ModuleSource::SourceFile(node) => {
-                m.collect_from_item_owner(db, cfg_options, source_map, node, src.file_id)
-            }
-            ModuleSource::Module(node) => {
-                let item_list = node.item_list().expect("inline module should have item list");
-                m.collect_from_item_owner(db, cfg_options, source_map, &item_list, src.file_id)
-            }
-        };
-        m
-    }
-    fn collect_from_item_owner(
-        &mut self,
-        db: &(impl DefDatabase + AstDatabase),
-        cfg_options: &CfgOptions,
-        source_map: &mut ImplSourceMap,
-        owner: &dyn ast::ModuleItemOwner,
-        file_id: HirFileId,
-    ) {
-        let hygiene = Hygiene::new(db, file_id);
-        for item in owner.items_with_macros() {
-            match item {
-                ast::ItemOrMacro::Item(ast::ModuleItem::ImplBlock(impl_block_ast)) => {
-                    let attrs = Attr::from_attrs_owner(&impl_block_ast, &hygiene);
-                    if attrs.map_or(false, |attrs| {
-                        attrs.iter().any(|attr| attr.is_cfg_enabled(cfg_options) == Some(false))
-                    }) {
-                        continue;
-                    }
-                    let impl_block = ImplData::from_ast(db, file_id, self.module, &impl_block_ast);
-                    let id = self.impls.alloc(impl_block);
-                    for &impl_item in &self.impls[id].items {
-                        self.impls_by_def.insert(impl_item, id);
-                    }
-                    source_map.insert(id, file_id, &impl_block_ast);
-                }
-                ast::ItemOrMacro::Item(_) => (),
-                ast::ItemOrMacro::Macro(macro_call) => {
-                    let attrs = Attr::from_attrs_owner(&macro_call, &hygiene);
-                    if attrs.map_or(false, |attrs| {
-                        attrs.iter().any(|attr| attr.is_cfg_enabled(cfg_options) == Some(false))
-                    }) {
-                        continue;
-                    }
-                    //FIXME: we should really cut down on the boilerplate required to process a macro
-                    let ast_id = AstId::new(file_id, db.ast_id_map(file_id).ast_id(&macro_call));
-                    if let Some(path) =
-                        macro_call.path().and_then(|path| Path::from_src(path, &hygiene))
-                    {
-                        if let Some(def) = self.module.resolver(db).resolve_path_as_macro(db, &path)
-                        {
-                            let call_id = db.intern_macro(MacroCallLoc { def: def.id, ast_id });
-                            let file_id = call_id.as_file(MacroFileKind::Items);
-                            if let Some(item_list) =
-                                db.parse_or_expand(file_id).and_then(ast::MacroItems::cast)
-                            {
-                                self.collect_from_item_owner(
-                                    db,
-                                    cfg_options,
-                                    source_map,
-                                    &item_list,
-                                    file_id,
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs
index e1780ed38..fa2ef8a17 100644
--- a/crates/ra_hir/src/lang_item.rs
+++ b/crates/ra_hir/src/lang_item.rs
@@ -25,7 +25,7 @@ impl LangItemTarget {
        Some(match self {
            LangItemTarget::Enum(e) => e.module(db).krate(),
            LangItemTarget::Function(f) => f.module(db).krate(),
-            LangItemTarget::ImplBlock(i) => i.module().krate(),
+            LangItemTarget::ImplBlock(i) => i.krate(db),
            LangItemTarget::Static(s) => s.module(db).krate(),
            LangItemTarget::Struct(s) => s.module(db).krate(),
            LangItemTarget::Trait(t) => t.module(db).krate(),
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 5ba847d35..da33c9591 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -54,12 +54,11 @@ mod test_db;
 #[cfg(test)]
 mod marks;
-use hir_expand::AstId;
+use crate::resolve::Resolver;
-use crate::{ids::MacroFileKind, resolve::Resolver};
 pub use crate::{
    adt::VariantDef,
+    code_model::ImplBlock,
    code_model::{
        attrs::{AttrDef, Attrs},
        docs::{DocDef, Docs, Documentation},
@@ -72,7 +71,6 @@ pub use crate::{
    from_source::FromSource,
    generics::GenericDef,
    ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
-    impl_block::ImplBlock,
    resolve::ScopeDef,
    source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
    ty::{
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
index 2fb913108..79b92180a 100644
--- a/crates/ra_hir/src/resolve.rs
+++ b/crates/ra_hir/src/resolve.rs
@@ -15,9 +15,8 @@ use crate::{
    db::{DefDatabase, HirDatabase},
    expr::{ExprScopes, PatId, ScopeId},
    generics::GenericParams,
-    impl_block::ImplBlock,
+    Adt, Const, DefWithBody, Enum, EnumVariant, Function, ImplBlock, Local, MacroDef, ModuleDef,
-    Adt, Const, DefWithBody, Enum, EnumVariant, Function, Local, MacroDef, ModuleDef, PerNs,
+    PerNs, Static, Struct, Trait, TypeAlias,
-    Static, Struct, Trait, TypeAlias,
 };
 #[derive(Debug, Clone, Default)]
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 662d3f880..5764dc26d 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -12,7 +12,6 @@ use hir_def::{
    path::known,
 };
 use hir_expand::{name::AsName, Source};
-use ra_db::FileId;
 use ra_syntax::{
    ast::{self, AstNode},
    match_ast, AstPtr,
@@ -30,52 +29,45 @@ use crate::{
    HirFileId, Local, MacroDef, Module, Name, Path, Resolver, Static, Struct, Ty,
 };
-fn try_get_resolver_for_node(
+fn try_get_resolver_for_node(db: &impl HirDatabase, node: Source<&SyntaxNode>) -> Option<Resolver> {
-    db: &impl HirDatabase,
-    file_id: FileId,
-    node: &SyntaxNode,
-) -> Option<Resolver> {
    match_ast! {
-        match node {
+        match (node.ast) {
            ast::Module(it) => {
-                let src = crate::Source { file_id: file_id.into(), ast: it };
+                let src = node.with_ast(it);
                Some(crate::Module::from_declaration(db, src)?.resolver(db))
            },
             ast::SourceFile(it) => {
-                let src =
+                let src = node.with_ast(crate::ModuleSource::SourceFile(it));
-                    crate::Source { file_id: file_id.into(), ast: crate::ModuleSource::SourceFile(it) };
                Some(crate::Module::from_definition(db, src)?.resolver(db))
            },
            ast::StructDef(it) => {
-                let src = crate::Source { file_id: file_id.into(), ast: it };
+                let src = node.with_ast(it);
                Some(Struct::from_source(db, src)?.resolver(db))
            },
            ast::EnumDef(it) => {
-                let src = crate::Source { file_id: file_id.into(), ast: it };
+                let src = node.with_ast(it);
                Some(Enum::from_source(db, src)?.resolver(db))
            },
-            _ => {
+            _ => match node.ast.kind() {
-                if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
+                FN_DEF | CONST_DEF | STATIC_DEF => {
-                    Some(def_with_body_from_child_node(db, file_id, node)?.resolver(db))
+                    Some(def_with_body_from_child_node(db, node)?.resolver(db))
-                } else {
-                    // FIXME add missing cases
-                    None
                }
-            },
+                // FIXME add missing cases
+                _ => None
+            }
        }
    }
 }
 fn def_with_body_from_child_node(
    db: &impl HirDatabase,
-    file_id: FileId,
+    child: Source<&SyntaxNode>,
-    node: &SyntaxNode,
 ) -> Option<DefWithBody> {
-    let src = crate::ModuleSource::from_child_node(db, file_id, node);
+    let module_source = crate::ModuleSource::from_child_node(db, child);
-    let module = Module::from_definition(db, crate::Source { file_id: file_id.into(), ast: src })?;
+    let module = Module::from_definition(db, Source::new(child.file_id, module_source))?;
-    let ctx = LocationCtx::new(db, module.id, file_id.into());
+    let ctx = LocationCtx::new(db, module.id, child.file_id);
-    node.ancestors().find_map(|node| {
+    child.ast.ancestors().find_map(|node| {
        match_ast! {
            match node {
                ast::FnDef(def)  => { Some(Function {id: ctx.to_def(&def) }.into()) },
@@ -91,8 +83,7 @@ fn def_with_body_from_child_node(
 /// original source files. It should not be used inside the HIR itself.
 #[derive(Debug)]
 pub struct SourceAnalyzer {
-    // FIXME: this doesn't handle macros at all
+    file_id: HirFileId,
-    file_id: FileId,
    resolver: Resolver,
    body_owner: Option<DefWithBody>,
    body_source_map: Option<Arc<BodySourceMap>>,
@@ -138,17 +129,16 @@ pub struct ReferenceDescriptor {
 impl SourceAnalyzer {
    pub fn new(
        db: &impl HirDatabase,
-        file_id: FileId,
+        node: Source<&SyntaxNode>,
-        node: &SyntaxNode,
        offset: Option<TextUnit>,
    ) -> SourceAnalyzer {
-        let def_with_body = def_with_body_from_child_node(db, file_id, node);
+        let def_with_body = def_with_body_from_child_node(db, node);
        if let Some(def) = def_with_body {
            let source_map = def.body_source_map(db);
            let scopes = def.expr_scopes(db);
            let scope = match offset {
-                None => scope_for(&scopes, &source_map, file_id.into(), &node),
+                None => scope_for(&scopes, &source_map, node),
-                Some(offset) => scope_for_offset(&scopes, &source_map, file_id.into(), offset),
+                Some(offset) => scope_for_offset(&scopes, &source_map, node.with_ast(offset)),
            };
            let resolver = expr::resolver_for_scope(db, def, scope);
            SourceAnalyzer {
@@ -157,30 +147,31 @@ impl SourceAnalyzer {
                body_source_map: Some(source_map),
                infer: Some(def.infer(db)),
                scopes: Some(scopes),
-                file_id,
+                file_id: node.file_id,
            }
        } else {
            SourceAnalyzer {
                resolver: node
+                    .ast
                    .ancestors()
-                    .find_map(|node| try_get_resolver_for_node(db, file_id, &node))
+                    .find_map(|it| try_get_resolver_for_node(db, node.with_ast(&it)))
                    .unwrap_or_default(),
                body_owner: None,
                body_source_map: None,
                infer: None,
                scopes: None,
-                file_id,
+                file_id: node.file_id,
            }
        }
    }
    fn expr_id(&self, expr: &ast::Expr) -> Option<ExprId> {
-        let src = Source { file_id: self.file_id.into(), ast: expr };
+        let src = Source { file_id: self.file_id, ast: expr };
        self.body_source_map.as_ref()?.node_expr(src)
    }
    fn pat_id(&self, pat: &ast::Pat) -> Option<PatId> {
-        let src = Source { file_id: self.file_id.into(), ast: pat };
+        let src = Source { file_id: self.file_id, ast: pat };
        self.body_source_map.as_ref()?.node_pat(src)
    }
@@ -288,7 +279,7 @@ impl SourceAnalyzer {
        let name = name_ref.as_name();
        let source_map = self.body_source_map.as_ref()?;
        let scopes = self.scopes.as_ref()?;
-        let scope = scope_for(scopes, source_map, self.file_id.into(), name_ref.syntax())?;
+        let scope = scope_for(scopes, source_map, Source::new(self.file_id, name_ref.syntax()))?;
        let entry = scopes.resolve_name_in_scope(scope, &name)?;
        Some(ScopeEntryWithSyntax {
            name: entry.name().clone(),
@@ -409,20 +400,19 @@ impl SourceAnalyzer {
 fn scope_for(
    scopes: &ExprScopes,
    source_map: &BodySourceMap,
-    file_id: HirFileId,
+    node: Source<&SyntaxNode>,
-    node: &SyntaxNode,
 ) -> Option<ScopeId> {
-    node.ancestors()
+    node.ast
+        .ancestors()
        .filter_map(ast::Expr::cast)
-        .filter_map(|it| source_map.node_expr(Source { file_id, ast: &it }))
+        .filter_map(|it| source_map.node_expr(Source::new(node.file_id, &it)))
        .find_map(|it| scopes.scope_for(it))
 }
 fn scope_for_offset(
    scopes: &ExprScopes,
    source_map: &BodySourceMap,
-    file_id: HirFileId,
+    offset: Source<TextUnit>,
-    offset: TextUnit,
 ) -> Option<ScopeId> {
    scopes
        .scope_by_expr()
@@ -430,7 +420,7 @@ fn scope_for_offset(
        .filter_map(|(id, scope)| {
            let source = source_map.expr_syntax(*id)?;
            // FIXME: correctly handle macro expansion
-            if source.file_id != file_id {
+            if source.file_id != offset.file_id {
                return None;
            }
            let syntax_node_ptr =
@@ -439,9 +429,14 @@ fn scope_for_offset(
        })
        // find containing scope
        .min_by_key(|(ptr, _scope)| {
-            (!(ptr.range().start() <= offset && offset <= ptr.range().end()), ptr.range().len())
+            (
+                !(ptr.range().start() <= offset.ast && offset.ast <= ptr.range().end()),
+                ptr.range().len(),
+            )
+        })
+        .map(|(ptr, scope)| {
+            adjust(scopes, source_map, ptr, offset.file_id, offset.ast).unwrap_or(*scope)
        })
-        .map(|(ptr, scope)| adjust(scopes, source_map, ptr, file_id, offset).unwrap_or(*scope))
 }
 // XXX: during completion, cursor might be outside of any particular
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index eb5ca6769..9aad2d3fe 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -5,16 +5,14 @@
 use std::sync::Arc;
 use arrayvec::ArrayVec;
-use hir_def::CrateModuleId;
 use rustc_hash::FxHashMap;
 use crate::{
    db::HirDatabase,
-    impl_block::{ImplBlock, ImplId},
    resolve::Resolver,
    ty::primitive::{FloatBitness, Uncertain},
    ty::{Ty, TypeCtor},
-    AssocItem, Crate, Function, Module, Mutability, Name, Trait,
+    AssocItem, Crate, Function, ImplBlock, Module, Mutability, Name, Trait,
 };
 use super::{autoderef, lower, Canonical, InEnvironment, TraitEnvironment, TraitRef};
@@ -39,65 +37,46 @@ impl TyFingerprint {
 #[derive(Debug, PartialEq, Eq)]
 pub struct CrateImplBlocks {
-    /// To make sense of the CrateModuleIds, we need the source root.
+    impls: FxHashMap<TyFingerprint, Vec<ImplBlock>>,
-    krate: Crate,
+    impls_by_trait: FxHashMap<Trait, Vec<ImplBlock>>,
-    impls: FxHashMap<TyFingerprint, Vec<(CrateModuleId, ImplId)>>,
-    impls_by_trait: FxHashMap<Trait, Vec<(CrateModuleId, ImplId)>>,
 }
 impl CrateImplBlocks {
-    pub fn lookup_impl_blocks<'a>(&'a self, ty: &Ty) -> impl Iterator<Item = ImplBlock> + 'a {
+    pub(crate) fn impls_in_crate_query(
+        db: &impl HirDatabase,
+        krate: Crate,
+    ) -> Arc<CrateImplBlocks> {
+        let mut crate_impl_blocks =
+            CrateImplBlocks { impls: FxHashMap::default(), impls_by_trait: FxHashMap::default() };
+        if let Some(module) = krate.root_module(db) {
+            crate_impl_blocks.collect_recursive(db, module);
+        }
+        Arc::new(crate_impl_blocks)
+    }
+    pub fn lookup_impl_blocks(&self, ty: &Ty) -> impl Iterator<Item = ImplBlock> + '_ {
        let fingerprint = TyFingerprint::for_impl(ty);
-        fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flat_map(|i| i.iter()).map(
+        fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flatten().copied()
-            move |(module_id, impl_id)| {
-                let module = Module::new(self.krate, *module_id);
-                ImplBlock::from_id(module, *impl_id)
-            },
-        )
    }
-    pub fn lookup_impl_blocks_for_trait<'a>(
+    pub fn lookup_impl_blocks_for_trait(&self, tr: Trait) -> impl Iterator<Item = ImplBlock> + '_ {
-        &'a self,
+        self.impls_by_trait.get(&tr).into_iter().flatten().copied()
-        tr: Trait,
-    ) -> impl Iterator<Item = ImplBlock> + 'a {
-        self.impls_by_trait.get(&tr).into_iter().flat_map(|i| i.iter()).map(
-            move |(module_id, impl_id)| {
-                let module = Module::new(self.krate, *module_id);
-                ImplBlock::from_id(module, *impl_id)
-            },
-        )
    }
    pub fn all_impls<'a>(&'a self) -> impl Iterator<Item = ImplBlock> + 'a {
-        self.impls.values().chain(self.impls_by_trait.values()).flat_map(|i| i.iter()).map(
+        self.impls.values().chain(self.impls_by_trait.values()).flatten().copied()
-            move |(module_id, impl_id)| {
-                let module = Module::new(self.krate, *module_id);
-                ImplBlock::from_id(module, *impl_id)
-            },
-        )
    }
    fn collect_recursive(&mut self, db: &impl HirDatabase, module: Module) {
-        let module_impl_blocks = db.impls_in_module(module);
+        for impl_block in module.impl_blocks(db) {
-        for (impl_id, _) in module_impl_blocks.impls.iter() {
-            let impl_block = ImplBlock::from_id(module_impl_blocks.module, impl_id);
            let target_ty = impl_block.target_ty(db);
            if impl_block.target_trait(db).is_some() {
                if let Some(tr) = impl_block.target_trait_ref(db) {
-                    self.impls_by_trait
+                    self.impls_by_trait.entry(tr.trait_).or_default().push(impl_block);
-                        .entry(tr.trait_)
-                        .or_insert_with(Vec::new)
-                        .push((module.id.module_id, impl_id));
                }
            } else {
                if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) {
-                    self.impls
+                    self.impls.entry(target_ty_fp).or_default().push(impl_block);
-                        .entry(target_ty_fp)
-                        .or_insert_with(Vec::new)
-                        .push((module.id.module_id, impl_id));
                }
            }
        }
@@ -106,21 +85,6 @@ impl CrateImplBlocks {
            self.collect_recursive(db, child);
        }
    }
-    pub(crate) fn impls_in_crate_query(
-        db: &impl HirDatabase,
-        krate: Crate,
-    ) -> Arc<CrateImplBlocks> {
-        let mut crate_impl_blocks = CrateImplBlocks {
-            krate,
-            impls: FxHashMap::default(),
-            impls_by_trait: FxHashMap::default(),
-        };
-        if let Some(module) = krate.root_module(db) {
-            crate_impl_blocks.collect_recursive(db, module);
-        }
-        Arc::new(crate_impl_blocks)
-    }
 }
 fn def_crates(db: &impl HirDatabase, cur_crate: Crate, ty: &Ty) -> Option<ArrayVec<[Crate; 2]>> {
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index fe9346c78..9a26e02fa 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -1,3 +1,6 @@
+mod never_type;
+mod coercion;
 use std::fmt::Write;
 use std::sync::Arc;
@@ -11,7 +14,7 @@ use ra_syntax::{
 use test_utils::covers;
 use crate::{
-    expr::BodySourceMap, test_db::TestDB, ty::display::HirDisplay, ty::InferenceResult,
+    expr::BodySourceMap, test_db::TestDB, ty::display::HirDisplay, ty::InferenceResult, Source,
    SourceAnalyzer,
 };
@@ -19,9 +22,6 @@ use crate::{
 // against snapshots of the expected results using insta. Use cargo-insta to
 // update the snapshots.
-mod never_type;
-mod coercion;
 #[test]
 fn cfg_impl_block() {
    let (db, pos) = TestDB::with_position(
@@ -4609,7 +4609,8 @@ fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
 fn type_at_pos(db: &TestDB, pos: FilePosition) -> String {
    let file = db.parse(pos.file_id).ok().unwrap();
    let expr = algo::find_node_at_offset::<ast::Expr>(file.syntax(), pos.offset).unwrap();
-    let analyzer = SourceAnalyzer::new(db, pos.file_id, expr.syntax(), Some(pos.offset));
+    let analyzer =
+        SourceAnalyzer::new(db, Source::new(pos.file_id.into(), expr.syntax()), Some(pos.offset));
    let ty = analyzer.type_of(db, &expr).unwrap();
    ty.display(db).to_string()
 }
@@ -4674,7 +4675,7 @@ fn infer(content: &str) -> String {
    for node in source_file.syntax().descendants() {
        if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
-            let analyzer = SourceAnalyzer::new(&db, file_id, &node, None);
+            let analyzer = SourceAnalyzer::new(&db, Source::new(file_id.into(), &node), None);
            infer_def(analyzer.inference_result(), analyzer.body_source_map());
        }
    }
@@ -4715,7 +4716,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
        let file = db.parse(pos.file_id).ok().unwrap();
        let node = file.syntax().token_at_offset(pos.offset).right_biased().unwrap().parent();
        let events = db.log_executed(|| {
-            SourceAnalyzer::new(&db, pos.file_id, &node, None);
+            SourceAnalyzer::new(&db, Source::new(pos.file_id.into(), &node), None);
        });
        assert!(format!("{:?}", events).contains("infer"))
    }
@@ -4735,7 +4736,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
        let file = db.parse(pos.file_id).ok().unwrap();
        let node = file.syntax().token_at_offset(pos.offset).right_biased().unwrap().parent();
        let events = db.log_executed(|| {
-            SourceAnalyzer::new(&db, pos.file_id, &node, None);
+            SourceAnalyzer::new(&db, Source::new(pos.file_id.into(), &node), None);
        });
        assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
    }
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 75351c17d..68304b950 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -191,11 +191,11 @@ impl ToChalk for Impl {
    type Chalk = chalk_ir::ImplId;
    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::ImplId {
-        db.intern_impl(self).into()
+        db.intern_chalk_impl(self).into()
    }
    fn from_chalk(db: &impl HirDatabase, impl_id: chalk_ir::ImplId) -> Impl {
-        db.lookup_intern_impl(impl_id.into())
+        db.lookup_intern_chalk_impl(impl_id.into())
    }
 }
@@ -630,7 +630,7 @@ fn impl_block_datum(
        .target_trait_ref(db)
        .expect("FIXME handle unresolved impl block trait ref")
        .subst(&bound_vars);
-    let impl_type = if impl_block.module().krate() == krate {
+    let impl_type = if impl_block.krate(db) == krate {
        chalk_rust_ir::ImplType::Local
    } else {
        chalk_rust_ir::ImplType::External
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index 40b5920d9..348aca07f 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -8,30 +8,32 @@ use ra_syntax::ast;
 use crate::{
    adt::{EnumData, StructData},
    body::{scope::ExprScopes, Body, BodySourceMap},
+    imp::ImplData,
    nameres::{
        raw::{ImportSourceMap, RawItems},
        CrateDefMap,
    },
-    DefWithBodyId, EnumId, StructOrUnionId,
+    DefWithBodyId, EnumId, ImplId, ItemLoc, StructOrUnionId,
 };
 #[salsa::query_group(InternDatabaseStorage)]
 pub trait InternDatabase: SourceDatabase {
    #[salsa::interned]
-    fn intern_function(&self, loc: crate::ItemLoc<ast::FnDef>) -> crate::FunctionId;
+    fn intern_function(&self, loc: ItemLoc<ast::FnDef>) -> crate::FunctionId;
    #[salsa::interned]
-    fn intern_struct_or_union(&self, loc: crate::ItemLoc<ast::StructDef>)
+    fn intern_struct_or_union(&self, loc: ItemLoc<ast::StructDef>) -> crate::StructOrUnionId;
-        -> crate::StructOrUnionId;
    #[salsa::interned]
-    fn intern_enum(&self, loc: crate::ItemLoc<ast::EnumDef>) -> crate::EnumId;
+    fn intern_enum(&self, loc: ItemLoc<ast::EnumDef>) -> crate::EnumId;
    #[salsa::interned]
-    fn intern_const(&self, loc: crate::ItemLoc<ast::ConstDef>) -> crate::ConstId;
+    fn intern_const(&self, loc: ItemLoc<ast::ConstDef>) -> crate::ConstId;
    #[salsa::interned]
-    fn intern_static(&self, loc: crate::ItemLoc<ast::StaticDef>) -> crate::StaticId;
+    fn intern_static(&self, loc: ItemLoc<ast::StaticDef>) -> crate::StaticId;
    #[salsa::interned]
-    fn intern_trait(&self, loc: crate::ItemLoc<ast::TraitDef>) -> crate::TraitId;
+    fn intern_trait(&self, loc: ItemLoc<ast::TraitDef>) -> crate::TraitId;
    #[salsa::interned]
-    fn intern_type_alias(&self, loc: crate::ItemLoc<ast::TypeAliasDef>) -> crate::TypeAliasId;
+    fn intern_type_alias(&self, loc: ItemLoc<ast::TypeAliasDef>) -> crate::TypeAliasId;
+    #[salsa::interned]
+    fn intern_impl(&self, loc: ItemLoc<ast::ImplBlock>) -> crate::ImplId;
 }
 #[salsa::query_group(DefDatabase2Storage)]
@@ -54,6 +56,9 @@ pub trait DefDatabase2: InternDatabase + AstDatabase {
    #[salsa::invoke(EnumData::enum_data_query)]
    fn enum_data(&self, e: EnumId) -> Arc<EnumData>;
+    #[salsa::invoke(ImplData::impl_data_query)]
+    fn impl_data(&self, e: ImplId) -> Arc<ImplData>;
    #[salsa::invoke(Body::body_with_source_map_query)]
    fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);
diff --git a/crates/ra_hir_def/src/imp.rs b/crates/ra_hir_def/src/imp.rs
new file mode 100644
index 000000000..717991c40
--- /dev/null
+++ b/crates/ra_hir_def/src/imp.rs
@@ -0,0 +1,71 @@
+//! Defines hir-level representation of impls.
+//!
+//! The handling is similar, but is not quite the same as for other items,
+//! because `impl`s don't have names.
+use std::sync::Arc;
+use ra_syntax::ast;
+use crate::{
+    db::DefDatabase2, type_ref::TypeRef, AssocItemId, AstItemDef, ConstId, FunctionId, ImplId,
+    LocationCtx, TypeAliasId,
+};
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImplData {
+    target_trait: Option<TypeRef>,
+    target_type: TypeRef,
+    items: Vec<AssocItemId>,
+    negative: bool,
+}
+impl ImplData {
+    pub(crate) fn impl_data_query(db: &impl DefDatabase2, id: ImplId) -> Arc<ImplData> {
+        let src = id.source(db);
+        let items = db.ast_id_map(src.file_id);
+        let target_trait = src.ast.target_trait().map(TypeRef::from_ast);
+        let target_type = TypeRef::from_ast_opt(src.ast.target_type());
+        let negative = src.ast.is_negative();
+        let items = if let Some(item_list) = src.ast.item_list() {
+            let ctx = LocationCtx::new(db, id.module(db), src.file_id);
+            item_list
+                .impl_items()
+                .map(|item_node| match item_node {
+                    ast::ImplItem::FnDef(it) => {
+                        FunctionId::from_ast_id(ctx, items.ast_id(&it)).into()
+                    }
+                    ast::ImplItem::ConstDef(it) => {
+                        ConstId::from_ast_id(ctx, items.ast_id(&it)).into()
+                    }
+                    ast::ImplItem::TypeAliasDef(it) => {
+                        TypeAliasId::from_ast_id(ctx, items.ast_id(&it)).into()
+                    }
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
+        let res = ImplData { target_trait, target_type, items, negative };
+        Arc::new(res)
+    }
+    pub fn target_trait(&self) -> Option<&TypeRef> {
+        self.target_trait.as_ref()
+    }
+    pub fn target_type(&self) -> &TypeRef {
+        &self.target_type
+    }
+    pub fn items(&self) -> &[AssocItemId] {
+        &self.items
+    }
+    pub fn is_negative(&self) -> bool {
+        self.negative
+    }
+}
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index 3fab7965c..a240a10b8 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -13,6 +13,7 @@ pub mod path;
 pub mod type_ref;
 pub mod builtin_type;
 pub mod adt;
+pub mod imp;
 pub mod diagnostics;
 pub mod expr;
 pub mod body;
@@ -77,14 +78,13 @@ impl ModuleSource {
        }
    }
-    pub fn from_child_node(
+    pub fn from_child_node(db: &impl db::DefDatabase2, child: Source<&SyntaxNode>) -> ModuleSource {
-        db: &impl db::DefDatabase2,
+        if let Some(m) =
-        file_id: FileId,
+            child.ast.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi())
-        child: &SyntaxNode,
+        {
-    ) -> ModuleSource {
-        if let Some(m) = child.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi()) {
            ModuleSource::Module(m)
        } else {
+            let file_id = child.file_id.original_file(db);
            let source_file = db.parse(file_id).tree();
            ModuleSource::SourceFile(source_file)
        }
@@ -321,6 +321,18 @@ impl AstItemDef<ast::TypeAliasDef> for TypeAliasId {
    }
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ImplId(salsa::InternId);
+impl_intern_key!(ImplId);
+impl AstItemDef<ast::ImplBlock> for ImplId {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::ImplBlock>) -> Self {
+        db.intern_impl(loc)
+    }
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::ImplBlock> {
+        db.lookup_intern_impl(self)
+    }
+}
 macro_rules! impl_froms {
    ($e:ident: $($v:ident $(($($sv:ident),*))?),*) => {
        $(
@@ -384,3 +396,15 @@ pub enum DefWithBodyId {
 }
 impl_froms!(DefWithBodyId: FunctionId, ConstId, StaticId);
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum AssocItemId {
+    FunctionId(FunctionId),
+    ConstId(ConstId),
+    TypeAliasId(TypeAliasId),
+}
+// FIXME: not every function, ... is actually an assoc item. maybe we should make
+// sure that you can only turn actual assoc items into AssocItemIds. This would
+// require not implementing From, and instead having some checked way of
+// casting them, and somehow making the constructors private, which would be annoying.
+impl_froms!(AssocItemId: FunctionId, ConstId, TypeAliasId);
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index dfcec6443..e5b073a0f 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -73,7 +73,7 @@ use crate::{
        diagnostics::DefDiagnostic, path_resolution::ResolveMode, per_ns::PerNs, raw::ImportId,
    },
    path::Path,
-    AstId, CrateModuleId, FunctionId, ModuleDefId, ModuleId, TraitId,
+    AstId, CrateModuleId, FunctionId, ImplId, ModuleDefId, ModuleId, TraitId,
 };
 /// Contains all top-level defs from a macro-expanded crate
@@ -122,14 +122,15 @@ pub struct ModuleData {
    ///
    /// Note that non-inline modules, by definition, live inside non-macro file.
    pub definition: Option<FileId>,
+    pub impls: Vec<ImplId>,
 }
-#[derive(Default, Debug, PartialEq, Eq, Clone)]
+#[derive(Default, Debug, PartialEq, Eq)]
 pub(crate) struct Declarations {
    fns: FxHashMap<FileAstId<ast::FnDef>, FunctionId>,
 }
-#[derive(Debug, Default, PartialEq, Eq, Clone)]
+#[derive(Debug, Default, PartialEq, Eq)]
 pub struct ModuleScope {
    items: FxHashMap<Name, Resolution>,
    /// Macros visable in current module in legacy textual scope
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 5c899aff3..c9ccb9023 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -19,7 +19,7 @@ use crate::{
        per_ns::PerNs, raw, CrateDefMap, ModuleData, Resolution, ResolveMode,
    },
    path::{Path, PathKind},
-    AdtId, AstId, AstItemDef, ConstId, CrateModuleId, EnumId, EnumVariantId, FunctionId,
+    AdtId, AstId, AstItemDef, ConstId, CrateModuleId, EnumId, EnumVariantId, FunctionId, ImplId,
    LocationCtx, ModuleDefId, ModuleId, StaticId, StructId, StructOrUnionId, TraitId, TypeAliasId,
    UnionId,
 };
@@ -571,6 +571,15 @@ where
                        .push((self.module_id, import_id, self.raw_items[import_id].clone())),
                    raw::RawItemKind::Def(def) => self.define_def(&self.raw_items[def]),
                    raw::RawItemKind::Macro(mac) => self.collect_macro(&self.raw_items[mac]),
+                    raw::RawItemKind::Impl(imp) => {
+                        let module = ModuleId {
+                            krate: self.def_collector.def_map.krate,
+                            module_id: self.module_id,
+                        };
+                        let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id);
+                        let imp_id = ImplId::from_ast_id(ctx, self.raw_items[imp].ast_id);
+                        self.def_collector.def_map.modules[self.module_id].impls.push(imp_id)
+                    }
                }
            }
        }
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index f52002bc0..a0a2c7273 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -28,6 +28,7 @@ pub struct RawItems {
    imports: Arena<ImportId, ImportData>,
    defs: Arena<Def, DefData>,
    macros: Arena<Macro, MacroData>,
+    impls: Arena<Impl, ImplData>,
    /// items for top-level module
    items: Vec<RawItem>,
 }
@@ -121,6 +122,13 @@ impl Index<Macro> for RawItems {
    }
 }
+impl Index<Impl> for RawItems {
+    type Output = ImplData;
+    fn index(&self, idx: Impl) -> &ImplData {
+        &self.impls[idx]
+    }
+}
 // Avoid heap allocation on items without attributes.
 type Attrs = Option<Arc<[Attr]>>;
@@ -142,6 +150,7 @@ pub(super) enum RawItemKind {
    Import(ImportId),
    Def(Def),
    Macro(Macro),
+    Impl(Impl),
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -203,6 +212,15 @@ pub(super) struct MacroData {
    pub(super) builtin: bool,
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(super) struct Impl(RawId);
+impl_arena_id!(Impl);
+#[derive(Debug, PartialEq, Eq)]
+pub(super) struct ImplData {
+    pub(super) ast_id: FileAstId<ast::ImplBlock>,
+}
 struct RawItemsCollector {
    raw_items: RawItems,
    source_ast_id_map: Arc<AstIdMap>,
@@ -236,8 +254,8 @@ impl RawItemsCollector {
                self.add_extern_crate_item(current_module, extern_crate);
                return;
            }
-            ast::ModuleItem::ImplBlock(_) => {
+            ast::ModuleItem::ImplBlock(it) => {
-                // impls don't participate in name resolution
+                self.add_impl(current_module, it);
                return;
            }
            ast::ModuleItem::StructDef(it) => {
@@ -376,6 +394,13 @@ impl RawItemsCollector {
        self.push_item(current_module, attrs, RawItemKind::Macro(m));
    }
+    fn add_impl(&mut self, current_module: Option<Module>, imp: ast::ImplBlock) {
+        let attrs = self.parse_attrs(&imp);
+        let ast_id = self.source_ast_id_map.ast_id(&imp);
+        let imp = self.raw_items.impls.alloc(ImplData { ast_id });
+        self.push_item(current_module, attrs, RawItemKind::Impl(imp))
+    }
    fn push_import(
        &mut self,
        current_module: Option<Module>,
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 930789b0f..26531cb05 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -223,18 +223,30 @@ impl<N: AstNode> AstId<N> {
    }
 }
+/// FIXME: https://github.com/matklad/with ?
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct Source<T> {
    pub file_id: HirFileId,
+    // FIXME: this stores all kind of things, not only `ast`.
+    // There should be a better name...
    pub ast: T,
 }
 impl<T> Source<T> {
+    pub fn new(file_id: HirFileId, ast: T) -> Source<T> {
+        Source { file_id, ast }
+    }
+    // Similarly, naming here is stupid...
+    pub fn with_ast<U>(&self, ast: U) -> Source<U> {
+        Source::new(self.file_id, ast)
+    }
    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
-        Source { file_id: self.file_id, ast: f(self.ast) }
+        Source::new(self.file_id, f(self.ast))
    }
    pub fn as_ref(&self) -> Source<&T> {
-        Source { file_id: self.file_id, ast: &self.ast }
+        self.with_ast(&self.ast)
    }
    pub fn file_syntax(&self, db: &impl db::AstDatabase) -> SyntaxNode {
        db.parse_or_expand(self.file_id).expect("source created from invalid file")
diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index 3572825b5..41ee81511 100644
--- a/crates/ra_ide_api/src/call_info.rs
+++ b/crates/ra_ide_api/src/call_info.rs
@@ -19,7 +19,11 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
    let calling_node = FnCallNode::with_node(&syntax, position.offset)?;
    let name_ref = calling_node.name_ref()?;
-    let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
+    let analyzer = hir::SourceAnalyzer::new(
+        db,
+        hir::Source::new(position.file_id.into(), name_ref.syntax()),
+        None,
+    );
    let (mut call_info, has_self) = match &calling_node {
        FnCallNode::CallExpr(expr) => {
            //FIXME: apply subst
diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs
index 010b45141..5c9dec13e 100644
--- a/crates/ra_ide_api/src/change.rs
+++ b/crates/ra_ide_api/src/change.rs
@@ -271,7 +271,6 @@ impl RootDatabase {
        self.query(hir::db::AstIdMapQuery).sweep(sweep);
        self.query(hir::db::RawItemsWithSourceMapQuery).sweep(sweep);
-        self.query(hir::db::ImplsInModuleWithSourceMapQuery).sweep(sweep);
        self.query(hir::db::BodyWithSourceMapQuery).sweep(sweep);
        self.query(hir::db::ExprScopesQuery).sweep(sweep);
@@ -314,8 +313,6 @@ impl RootDatabase {
            hir::db::RawItemsWithSourceMapQuery
            hir::db::RawItemsQuery
            hir::db::CrateDefMapQuery
-            hir::db::ImplsInModuleWithSourceMapQuery
-            hir::db::ImplsInModuleQuery
            hir::db::GenericParamsQuery
            hir::db::FnDataQuery
            hir::db::TypeAliasDataQuery
@@ -340,6 +337,7 @@ impl RootDatabase {
            hir::db::TraitDatumQuery
            hir::db::StructDatumQuery
            hir::db::ImplDatumQuery
+            hir::db::ImplDataQuery
            hir::db::TraitSolveQuery
        ];
        acc.sort_by_key(|it| std::cmp::Reverse(it.1));
diff --git a/crates/ra_ide_api/src/completion/completion_context.rs b/crates/ra_ide_api/src/completion/completion_context.rs
index 64cbc0f98..0906a4e1b 100644
--- a/crates/ra_ide_api/src/completion/completion_context.rs
+++ b/crates/ra_ide_api/src/completion/completion_context.rs
@@ -58,8 +58,11 @@ impl<'a> CompletionContext<'a> {
        );
        let token =
            original_parse.tree().syntax().token_at_offset(position.offset).left_biased()?;
-        let analyzer =
+        let analyzer = hir::SourceAnalyzer::new(
-            hir::SourceAnalyzer::new(db, position.file_id, &token.parent(), Some(position.offset));
+            db,
+            hir::Source::new(position.file_id.into(), &token.parent()),
+            Some(position.offset),
+        );
        let mut ctx = CompletionContext {
            db,
            analyzer,
diff --git a/crates/ra_ide_api/src/goto_type_definition.rs b/crates/ra_ide_api/src/goto_type_definition.rs
index 71146591d..2327cb1e7 100644
--- a/crates/ra_ide_api/src/goto_type_definition.rs
+++ b/crates/ra_ide_api/src/goto_type_definition.rs
@@ -18,7 +18,8 @@ pub(crate) fn goto_type_definition(
            .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())
    })?;
-    let analyzer = hir::SourceAnalyzer::new(db, position.file_id, &node, None);
+    let analyzer =
+        hir::SourceAnalyzer::new(db, hir::Source::new(position.file_id.into(), &node), None);
    let ty: hir::Ty = if let Some(ty) =
        ast::Expr::cast(node.clone()).and_then(|e| analyzer.type_of(db, &e))
diff --git a/crates/ra_ide_api/src/hover.rs b/crates/ra_ide_api/src/hover.rs
index 07d511fb3..92b4b1f79 100644
--- a/crates/ra_ide_api/src/hover.rs
+++ b/crates/ra_ide_api/src/hover.rs
@@ -230,7 +230,8 @@ pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
        .ancestors()
        .take_while(|it| it.text_range() == leaf_node.text_range())
        .find(|it| ast::Expr::cast(it.clone()).is_some() || ast::Pat::cast(it.clone()).is_some())?;
-    let analyzer = hir::SourceAnalyzer::new(db, frange.file_id, &node, None);
+    let analyzer =
+        hir::SourceAnalyzer::new(db, hir::Source::new(frange.file_id.into(), &node), None);
    let ty = if let Some(ty) = ast::Expr::cast(node.clone()).and_then(|e| analyzer.type_of(db, &e))
    {
        ty
diff --git a/crates/ra_ide_api/src/inlay_hints.rs b/crates/ra_ide_api/src/inlay_hints.rs
index 2ff10b89a..0cd959848 100644
--- a/crates/ra_ide_api/src/inlay_hints.rs
+++ b/crates/ra_ide_api/src/inlay_hints.rs
@@ -32,6 +32,7 @@ fn get_inlay_hints(
    file_id: FileId,
    node: &SyntaxNode,
 ) -> Option<Vec<InlayHint>> {
+    let analyzer = SourceAnalyzer::new(db, hir::Source::new(file_id.into(), node), None);
    match_ast! {
        match node {
            ast::LetStmt(it) => {
@@ -39,11 +40,9 @@ fn get_inlay_hints(
                    return None;
                }
                let pat = it.pat()?;
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                Some(get_pat_type_hints(db, &analyzer, pat, false))
            },
            ast::LambdaExpr(it) => {
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                it.param_list().map(|param_list| {
                    param_list
                        .params()
@@ -56,21 +55,17 @@ fn get_inlay_hints(
            },
            ast::ForExpr(it) => {
                let pat = it.pat()?;
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                Some(get_pat_type_hints(db, &analyzer, pat, false))
            },
            ast::IfExpr(it) => {
                let pat = it.condition()?.pat()?;
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                Some(get_pat_type_hints(db, &analyzer, pat, true))
            },
            ast::WhileExpr(it) => {
                let pat = it.condition()?.pat()?;
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                Some(get_pat_type_hints(db, &analyzer, pat, true))
            },
            ast::MatchArmList(it) => {
-                let analyzer = SourceAnalyzer::new(db, file_id, it.syntax(), None);
                Some(
                    it
                        .arms()
diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
index 9cb9433e7..faa88d988 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -369,6 +369,21 @@ mod tests {
        assert_eq!(refs.len(), 2);
    }
+    #[test]
+    fn test_find_all_refs_macro_def() {
+        let code = r#"
+        #[macro_export]
+        macro_rules! m1<|> { () => (()) }
+        fn foo() {
+            m1();
+            m1();
+        }"#;
+        let refs = get_all_refs(code);
+        assert_eq!(refs.len(), 3);
+    }
    fn get_all_refs(text: &str) -> ReferenceSearchResult {
        let (analysis, position) = single_file_with_position(text);
        analysis.find_all_refs(position, None).unwrap().unwrap()
diff --git a/crates/ra_ide_api/src/references/classify.rs b/crates/ra_ide_api/src/references/classify.rs
index 217f9951e..f12b58cb9 100644
--- a/crates/ra_ide_api/src/references/classify.rs
+++ b/crates/ra_ide_api/src/references/classify.rs
@@ -21,7 +21,6 @@ pub(crate) fn classify_name(
    let parent = name.syntax().parent()?;
    let file_id = file_id.into();
-    // FIXME: add ast::MacroCall(it)
    match_ast! {
        match parent {
            ast::BindPat(it) => {
@@ -104,6 +103,19 @@ pub(crate) fn classify_name(
                    Some(from_module_def(db, def.into(), None))
                }
            },
+            ast::MacroCall(it) => {
+                let src = hir::Source { file_id, ast: it};
+                let def = hir::MacroDef::from_source(db, src.clone())?;
+                let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
+                let module = Module::from_definition(db, Source::new(file_id, module_src))?;
+                Some(NameDefinition {
+                    visibility: None,
+                    container: module,
+                    kind: NameKind::Macro(def),
+                })
+            },
            _ => None,
        }
    }
@@ -114,12 +126,11 @@ pub(crate) fn classify_name_ref(
    file_id: FileId,
    name_ref: &ast::NameRef,
 ) -> Option<NameDefinition> {
-    use PathResolution::*;
    let _p = profile("classify_name_ref");
    let parent = name_ref.syntax().parent()?;
-    let analyzer = SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
+    let analyzer =
+        SourceAnalyzer::new(db, hir::Source::new(file_id.into(), name_ref.syntax()), None);
    if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
        tested_by!(goto_definition_works_for_methods);
@@ -146,8 +157,8 @@ pub(crate) fn classify_name_ref(
        }
    }
-    let ast = ModuleSource::from_child_node(db, file_id, &parent);
    let file_id = file_id.into();
+    let ast = ModuleSource::from_child_node(db, Source::new(file_id, &parent));
    // FIXME: find correct container and visibility for each case
    let container = Module::from_definition(db, Source { file_id, ast })?;
    let visibility = None;
@@ -163,26 +174,26 @@ pub(crate) fn classify_name_ref(
    let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
    let resolved = analyzer.resolve_path(db, &path)?;
    match resolved {
-        Def(def) => Some(from_module_def(db, def, Some(container))),
+        PathResolution::Def(def) => Some(from_module_def(db, def, Some(container))),
-        AssocItem(item) => Some(from_assoc_item(db, item)),
+        PathResolution::AssocItem(item) => Some(from_assoc_item(db, item)),
-        Local(local) => {
+        PathResolution::Local(local) => {
            let container = local.module(db);
            let kind = NameKind::Local(local);
            Some(NameDefinition { kind, container, visibility: None })
        }
-        GenericParam(par) => {
+        PathResolution::GenericParam(par) => {
            // FIXME: get generic param def
            let kind = NameKind::GenericParam(par);
            Some(NameDefinition { kind, container, visibility })
        }
-        Macro(def) => {
+        PathResolution::Macro(def) => {
            let kind = NameKind::Macro(def);
            Some(NameDefinition { kind, container, visibility })
        }
-        SelfType(impl_block) => {
+        PathResolution::SelfType(impl_block) => {
            let ty = impl_block.target_ty(db);
            let kind = NameKind::SelfType(ty);
-            let container = impl_block.module();
+            let container = impl_block.module(db);
            Some(NameDefinition { kind, container, visibility })
        }
    }
diff --git a/crates/ra_ide_api/src/runnables.rs b/crates/ra_ide_api/src/runnables.rs
index 366ac8048..8039a5164 100644
--- a/crates/ra_ide_api/src/runnables.rs
+++ b/crates/ra_ide_api/src/runnables.rs
@@ -1,5 +1,6 @@
 //! FIXME: write short doc here
+use hir::Source;
 use itertools::Itertools;
 use ra_db::SourceDatabase;
 use ra_syntax::{
@@ -65,9 +66,8 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Opti
        return None;
    }
    let range = module.syntax().text_range();
-    let src = hir::ModuleSource::from_child_node(db, file_id, &module.syntax());
+    let src = hir::ModuleSource::from_child_node(db, Source::new(file_id.into(), &module.syntax()));
-    let module =
+    let module = hir::Module::from_definition(db, Source::new(file_id.into(), src))?;
-        hir::Module::from_definition(db, hir::Source { file_id: file_id.into(), ast: src })?;
    let path = module.path_to_root(db).into_iter().rev().filter_map(|it| it.name(db)).join("::");
    Some(Runnable { range, kind: RunnableKind::TestMod { path } })
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 45f2e3de4..81d4f75f9 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -290,6 +290,22 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>,
        let m = lhs.precede(p);
        p.bump(op);
+        if is_range {
+            // test postfix_range
+            // fn foo() {
+            //     let x = 1..;
+            //     match 1.. { _ => () };
+            //     match a.b()..S { _ => () };
+            // }
+            let has_trailing_expression =
+                p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{']));
+            if !has_trailing_expression {
+                // no RHS
+                lhs = m.complete(p, RANGE_EXPR);
+                break;
+            }
+        }
        expr_bp(p, r, op_bp + 1);
        lhs = m.complete(p, if is_range { RANGE_EXPR } else { BIN_EXPR });
    }
@@ -330,7 +346,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
                if p.at(op) {
                    m = p.start();
                    p.bump(op);
-                    if p.at_ts(EXPR_FIRST) {
+                    if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{'])) {
                        expr_bp(p, r, 2);
                    }
                    return Some((m.complete(p, RANGE_EXPR), BlockLike::NotBlock));
@@ -344,13 +360,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
            // }
            //
            let (lhs, blocklike) = atom::atom_expr(p, r)?;
-            return Some(postfix_expr(
+            return Some(postfix_expr(p, lhs, blocklike, !(r.prefer_stmt && blocklike.is_block())));
-                p,
-                lhs,
-                blocklike,
-                !(r.prefer_stmt && blocklike.is_block()),
-                r.forbid_structs,
-            ));
        }
    };
    // parse the interior of the unary expression
@@ -366,7 +376,6 @@ fn postfix_expr(
    // `while true {break}; ();`
    mut block_like: BlockLike,
    mut allow_calls: bool,
-    forbid_structs: bool,
 ) -> (CompletedMarker, BlockLike) {
    loop {
        lhs = match p.current() {
@@ -380,7 +389,7 @@ fn postfix_expr(
            // }
            T!['('] if allow_calls => call_expr(p, lhs),
            T!['['] if allow_calls => index_expr(p, lhs),
-            T![.] => match postfix_dot_expr(p, lhs, forbid_structs) {
+            T![.] => match postfix_dot_expr(p, lhs) {
                Ok(it) => it,
                Err(it) => {
                    lhs = it;
@@ -398,7 +407,6 @@ fn postfix_expr(
    fn postfix_dot_expr(
        p: &mut Parser,
        lhs: CompletedMarker,
-        forbid_structs: bool,
    ) -> Result<CompletedMarker, CompletedMarker> {
        assert!(p.at(T![.]));
        if p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth_at(2, T![::])) {
@@ -418,25 +426,8 @@ fn postfix_expr(
            return Ok(m.complete(p, AWAIT_EXPR));
        }
-        // test postfix_range
+        if p.at(T![..=]) || p.at(T![..]) {
-        // fn foo() {
+            return Err(lhs);
-        //     let x = 1..;
-        //     match 1.. { _ => () };
-        //     match a.b()..S { _ => () };
-        // }
-        for &(op, la) in &[(T![..=], 3), (T![..], 2)] {
-            if p.at(op) {
-                let next_token = p.nth(la);
-                let has_trailing_expression =
-                    !(forbid_structs && next_token == T!['{']) && EXPR_FIRST.contains(next_token);
-                return if has_trailing_expression {
-                    Err(lhs)
-                } else {
-                    let m = lhs.precede(p);
-                    p.bump(op);
-                    Ok(m.complete(p, RANGE_EXPR))
-                };
-            }
        }
        Ok(field_expr(p, lhs))
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 1ec9881b9..277532a8c 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -16,7 +16,7 @@ use crate::{
 };
 pub use self::{
-    expr_extensions::{ArrayExprKind, BinOp, ElseBranch, LiteralKind, PrefixOp},
+    expr_extensions::{ArrayExprKind, BinOp, ElseBranch, LiteralKind, PrefixOp, RangeOp},
    extensions::{FieldKind, PathSegmentKind, SelfParamKind, StructKind, TypeBoundKind},
    generated::*,
    tokens::*,
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
index 25dbd0bed..7c53aa934 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -189,6 +189,52 @@ impl ast::BinExpr {
    }
 }
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum RangeOp {
+    /// `..`
+    Exclusive,
+    /// `..=`
+    Inclusive,
+}
+impl ast::RangeExpr {
+    fn op_details(&self) -> Option<(usize, SyntaxToken, RangeOp)> {
+        self.syntax().children_with_tokens().enumerate().find_map(|(ix, child)| {
+            let token = child.into_token()?;
+            let bin_op = match token.kind() {
+                T![..] => RangeOp::Exclusive,
+                T![..=] => RangeOp::Inclusive,
+                _ => return None,
+            };
+            Some((ix, token, bin_op))
+        })
+    }
+    pub fn op_kind(&self) -> Option<RangeOp> {
+        self.op_details().map(|t| t.2)
+    }
+    pub fn op_token(&self) -> Option<SyntaxToken> {
+        self.op_details().map(|t| t.1)
+    }
+    pub fn start(&self) -> Option<ast::Expr> {
+        let op_ix = self.op_details()?.0;
+        self.syntax()
+            .children_with_tokens()
+            .take(op_ix)
+            .find_map(|it| ast::Expr::cast(it.into_node()?))
+    }
+    pub fn end(&self) -> Option<ast::Expr> {
+        let op_ix = self.op_details()?.0;
+        self.syntax()
+            .children_with_tokens()
+            .skip(op_ix + 1)
+            .find_map(|it| ast::Expr::cast(it.into_node()?))
+    }
+}
 impl ast::IndexExpr {
    pub fn base(&self) -> Option<ast::Expr> {
        children(self).nth(0)
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 5dcb6a95a..9931fec84 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -176,9 +176,11 @@ impl SourceFile {
 /// ```
 #[macro_export]
 macro_rules! match_ast {
-    (match $node:ident {
+    (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
+    (match ($node:expr) {
        $( ast::$ast:ident($it:ident) => $res:block, )*
-        _ => $catch_all:expr,
+        _ => $catch_all:expr $(,)?
    }) => {{
        $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
        { $catch_all }
diff --git a/crates/ra_syntax/src/syntax_error.rs b/crates/ra_syntax/src/syntax_error.rs
index 1f60a7aab..6c171df8d 100644
--- a/crates/ra_syntax/src/syntax_error.rs
+++ b/crates/ra_syntax/src/syntax_error.rs
@@ -83,6 +83,7 @@ pub enum SyntaxErrorKind {
    InvalidMatchInnerAttr,
    InvalidTupleIndexFormat,
    VisibilityNotAllowed,
+    InclusiveRangeMissingEnd,
 }
 impl fmt::Display for SyntaxErrorKind {
@@ -103,6 +104,9 @@ impl fmt::Display for SyntaxErrorKind {
            VisibilityNotAllowed => {
                write!(f, "unnecessary visibility qualifier")
            }
+            InclusiveRangeMissingEnd => {
+                write!(f, "An inclusive range must have an end expression")
+            }
        }
    }
 }
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index 2d596763e..222ac15f8 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -103,6 +103,7 @@ pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> {
                ast::FieldExpr(it) => { validate_numeric_name(it.name_ref(), &mut errors) },
                ast::RecordField(it) => { validate_numeric_name(it.name_ref(), &mut errors) },
                ast::Visibility(it) => { validate_visibility(it, &mut errors) },
+                ast::RangeExpr(it) => { validate_range_expr(it, &mut errors) },
                _ => (),
            }
        }
@@ -227,3 +228,12 @@ fn validate_visibility(vis: ast::Visibility, errors: &mut Vec<SyntaxError>) {
            .push(SyntaxError::new(SyntaxErrorKind::VisibilityNotAllowed, vis.syntax.text_range()))
    }
 }
+fn validate_range_expr(expr: ast::RangeExpr, errors: &mut Vec<SyntaxError>) {
+    if expr.op_kind() == Some(ast::RangeOp::Inclusive) && expr.end().is_none() {
+        errors.push(SyntaxError::new(
+            SyntaxErrorKind::InclusiveRangeMissingEnd,
+            expr.syntax().text_range(),
+        ));
+    }
+}
diff --git a/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.rs b/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.rs
new file mode 100644
index 000000000..0b4ed7a2b
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.rs
@@ -0,0 +1,4 @@
+fn main() {
+    0..=;
+    ..=;
+}
diff --git a/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.txt b/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.txt
new file mode 100644
index 000000000..3810b9680
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/err/0038_endless_inclusive_range.txt
@@ -0,0 +1,30 @@
+SOURCE_FILE@[0; 33)
+  FN_DEF@[0; 32)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 32)
+      BLOCK@[10; 32)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 16) "\n    "
+        EXPR_STMT@[16; 21)
+          RANGE_EXPR@[16; 20)
+            LITERAL@[16; 17)
+              INT_NUMBER@[16; 17) "0"
+            DOTDOTEQ@[17; 20) "..="
+          SEMI@[20; 21) ";"
+        WHITESPACE@[21; 26) "\n    "
+        EXPR_STMT@[26; 30)
+          RANGE_EXPR@[26; 29)
+            DOTDOTEQ@[26; 29) "..="
+          SEMI@[29; 30) ";"
+        WHITESPACE@[30; 31) "\n"
+        R_CURLY@[31; 32) "}"
+  WHITESPACE@[32; 33) "\n"
+error [16; 20): An inclusive range must have an end expression
+error [26; 29): An inclusive range must have an end expression
diff --git a/crates/ra_syntax/test_data/parser/ok/0060_as_range.rs b/crates/ra_syntax/test_data/parser/ok/0060_as_range.rs
new file mode 100644
index 000000000..f063ffadb
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0060_as_range.rs
@@ -0,0 +1,4 @@
+fn main() {
+    0 as usize ..;
+    1 + 2 as usize ..;
+}
diff --git a/crates/ra_syntax/test_data/parser/ok/0060_as_range.txt b/crates/ra_syntax/test_data/parser/ok/0060_as_range.txt
new file mode 100644
index 000000000..ad0c4a3fe
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0060_as_range.txt
@@ -0,0 +1,56 @@
+SOURCE_FILE@[0; 56)
+  FN_DEF@[0; 55)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 55)
+      BLOCK@[10; 55)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 16) "\n    "
+        EXPR_STMT@[16; 30)
+          RANGE_EXPR@[16; 29)
+            CAST_EXPR@[16; 26)
+              LITERAL@[16; 17)
+                INT_NUMBER@[16; 17) "0"
+              WHITESPACE@[17; 18) " "
+              AS_KW@[18; 20) "as"
+              WHITESPACE@[20; 21) " "
+              PATH_TYPE@[21; 26)
+                PATH@[21; 26)
+                  PATH_SEGMENT@[21; 26)
+                    NAME_REF@[21; 26)
+                      IDENT@[21; 26) "usize"
+            WHITESPACE@[26; 27) " "
+            DOTDOT@[27; 29) ".."
+          SEMI@[29; 30) ";"
+        WHITESPACE@[30; 35) "\n    "
+        EXPR_STMT@[35; 53)
+          RANGE_EXPR@[35; 52)
+            BIN_EXPR@[35; 49)
+              LITERAL@[35; 36)
+                INT_NUMBER@[35; 36) "1"
+              WHITESPACE@[36; 37) " "
+              PLUS@[37; 38) "+"
+              WHITESPACE@[38; 39) " "
+              CAST_EXPR@[39; 49)
+                LITERAL@[39; 40)
+                  INT_NUMBER@[39; 40) "2"
+                WHITESPACE@[40; 41) " "
+                AS_KW@[41; 43) "as"
+                WHITESPACE@[43; 44) " "
+                PATH_TYPE@[44; 49)
+                  PATH@[44; 49)
+                    PATH_SEGMENT@[44; 49)
+                      NAME_REF@[44; 49)
+                        IDENT@[44; 49) "usize"
+            WHITESPACE@[49; 50) " "
+            DOTDOT@[50; 52) ".."
+          SEMI@[52; 53) ";"
+        WHITESPACE@[53; 54) "\n"
+        R_CURLY@[54; 55) "}"
+  WHITESPACE@[55; 56) "\n"
diff --git a/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.rs b/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.rs
new file mode 100644
index 000000000..2c4ed11e1
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.rs
@@ -0,0 +1,4 @@
+fn main() {
+    match .. {
+    }
+}
diff --git a/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.txt b/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.txt
new file mode 100644
index 000000000..bdfac9b76
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0061_match_full_range.txt
@@ -0,0 +1,27 @@
+SOURCE_FILE@[0; 35)
+  FN_DEF@[0; 34)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 34)
+      BLOCK@[10; 34)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 16) "\n    "
+        MATCH_EXPR@[16; 32)
+          MATCH_KW@[16; 21) "match"
+          WHITESPACE@[21; 22) " "
+          RANGE_EXPR@[22; 24)
+            DOTDOT@[22; 24) ".."
+          WHITESPACE@[24; 25) " "
+          MATCH_ARM_LIST@[25; 32)
+            L_CURLY@[25; 26) "{"
+            WHITESPACE@[26; 31) "\n    "
+            R_CURLY@[31; 32) "}"
+        WHITESPACE@[32; 33) "\n"
+        R_CURLY@[33; 34) "}"
+  WHITESPACE@[34; 35) "\n"