74 files changed, 1845 insertions, 1503 deletions
diff --git a/crates/ra_assists/src/fill_match_arms.rs b/crates/ra_assists/src/fill_match_arms.rs
index 30020b56e..6a22b0af5 100644
--- a/crates/ra_assists/src/fill_match_arms.rs
+++ b/crates/ra_assists/src/fill_match_arms.rs
@@ -23,8 +23,8 @@ pub(crate) fn fill_match_arms(mut ctx: AssistCtx<impl HirDatabase>) -> Option<As
    let function =
        source_binder::function_from_child_node(ctx.db, ctx.frange.file_id, expr.syntax())?;
    let infer_result = function.infer(ctx.db);
-    let syntax_mapping = function.body_syntax_mapping(ctx.db);
+    let source_map = function.body_source_map(ctx.db);
-    let node_expr = syntax_mapping.node_expr(expr)?;
+    let node_expr = source_map.node_expr(expr)?;
    let match_expr_ty = infer_result[node_expr].clone();
    let enum_def = match match_expr_ty {
        Ty::Adt { def_id: AdtDef::Enum(e), .. } => e,
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index da0f1ec94..3ac146950 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -5,11 +5,11 @@ use ra_db::{CrateId, SourceRootId, Edition};
 use ra_syntax::{ast::self, TreeArc, SyntaxNode};
 use crate::{
-    Name, ScopesWithSyntaxMapping, Ty, HirFileId,
+    Name, ScopesWithSourceMap, Ty, HirFileId,
    HirDatabase, PersistentHirDatabase,
    type_ref::TypeRef,
    nameres::{ModuleScope, Namespace, lower::ImportId},
-    expr::{Body, BodySyntaxMapping},
+    expr::{Body, BodySourceMap},
    ty::InferenceResult,
    adt::{EnumVariantId, StructFieldId, VariantDef},
    generics::GenericParams,
@@ -191,7 +191,7 @@ impl Module {
    }
    pub fn declarations(self, db: &impl HirDatabase) -> Vec<ModuleDef> {
-        let (lowered_module, _) = db.lower_module(self);
+        let lowered_module = db.lower_module(self);
        lowered_module
            .declarations
            .values()
@@ -483,8 +483,8 @@ impl Function {
        self.signature(db).name.clone()
    }
-    pub fn body_syntax_mapping(&self, db: &impl HirDatabase) -> Arc<BodySyntaxMapping> {
+    pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
-        db.body_syntax_mapping(*self)
+        db.body_with_source_map(*self).1
    }
    pub fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
@@ -495,10 +495,10 @@ impl Function {
        db.type_for_def((*self).into(), Namespace::Values)
    }
-    pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSyntaxMapping {
+    pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSourceMap {
        let scopes = db.expr_scopes(*self);
-        let syntax_mapping = db.body_syntax_mapping(*self);
+        let source_map = db.body_with_source_map(*self).1;
-        ScopesWithSyntaxMapping { scopes, syntax_mapping }
+        ScopesWithSourceMap { scopes, source_map }
    }
    pub fn signature(&self, db: &impl HirDatabase) -> Arc<FnSignature> {
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 2d3058afd..437f96942 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -47,7 +47,7 @@ impl Module {
        db: &impl HirDatabase,
        import: ImportId,
    ) -> TreeArc<ast::PathSegment> {
-        let source_map = db.lower_module_source_map(*self);
+        let (_, source_map) = db.lower_module_with_source_map(*self);
        let (_, source) = self.definition_source(db);
        source_map.get(&source, import)
    }
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index ec848f1b2..21d22aa7f 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -48,14 +48,14 @@ pub trait PersistentHirDatabase: SourceDatabase + AsRef<HirInterner> {
        delc_id: Option<SourceFileItemId>,
    ) -> Arc<Vec<crate::module_tree::Submodule>>;
-    #[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_query)]
+    #[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_with_source_map_query)]
-    fn lower_module(&self, module: Module) -> (Arc<LoweredModule>, Arc<ImportSourceMap>);
+    fn lower_module_with_source_map(
+        &self,
-    #[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_module_query)]
+        module: Module,
-    fn lower_module_module(&self, module: Module) -> Arc<LoweredModule>;
+    ) -> (Arc<LoweredModule>, Arc<ImportSourceMap>);
-    #[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_source_map_query)]
+    #[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_query)]
-    fn lower_module_source_map(&self, module: Module) -> Arc<ImportSourceMap>;
+    fn lower_module(&self, module: Module) -> Arc<LoweredModule>;
    #[salsa::invoke(crate::nameres::ItemMap::item_map_query)]
    fn item_map(&self, krate: Crate) -> Arc<ItemMap>;
@@ -105,11 +105,14 @@ pub trait HirDatabase: PersistentHirDatabase {
    #[salsa::invoke(crate::ty::type_for_field)]
    fn type_for_field(&self, field: StructField) -> Ty;
-    #[salsa::invoke(crate::expr::body_hir)]
+    #[salsa::invoke(crate::expr::body_with_source_map_query)]
-    fn body_hir(&self, func: Function) -> Arc<crate::expr::Body>;
+    fn body_with_source_map(
+        &self,
+        func: Function,
+    ) -> (Arc<crate::expr::Body>, Arc<crate::expr::BodySourceMap>);
-    #[salsa::invoke(crate::expr::body_syntax_mapping)]
+    #[salsa::invoke(crate::expr::body_hir_query)]
-    fn body_syntax_mapping(&self, func: Function) -> Arc<crate::expr::BodySyntaxMapping>;
+    fn body_hir(&self, func: Function) -> Arc<crate::expr::Body>;
    #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)]
    fn impls_in_crate(&self, krate: Crate) -> Arc<CrateImplBlocks>;
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index aa39d28ed..6c7489e63 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -16,7 +16,7 @@ use crate::{
 };
 use crate::{ path::GenericArgs, ty::primitive::{UintTy, UncertainIntTy, UncertainFloatTy}};
-pub use self::scope::{ExprScopes, ScopesWithSyntaxMapping, ScopeEntryWithSyntax};
+pub use self::scope::{ExprScopes, ScopesWithSourceMap, ScopeEntryWithSyntax};
 pub(crate) mod scope;
@@ -48,13 +48,12 @@ pub struct Body {
 /// expression containing it; but for type inference etc., we want to operate on
 /// a structure that is agnostic to the actual positions of expressions in the
 /// file, so that we don't recompute types whenever some whitespace is typed.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Default, Debug, Eq, PartialEq)]
-pub struct BodySyntaxMapping {
+pub struct BodySourceMap {
-    body: Arc<Body>,
+    expr_map: FxHashMap<SyntaxNodePtr, ExprId>,
-    expr_syntax_mapping: FxHashMap<SyntaxNodePtr, ExprId>,
+    expr_map_back: ArenaMap<ExprId, SyntaxNodePtr>,
-    expr_syntax_mapping_back: ArenaMap<ExprId, SyntaxNodePtr>,
+    pat_map: FxHashMap<SyntaxNodePtr, PatId>,
-    pat_syntax_mapping: FxHashMap<SyntaxNodePtr, PatId>,
+    pat_map_back: ArenaMap<PatId, SyntaxNodePtr>,
-    pat_syntax_mapping_back: ArenaMap<PatId, SyntaxNodePtr>,
 }
 impl Body {
@@ -77,10 +76,6 @@ impl Body {
    pub fn pats(&self) -> impl Iterator<Item = (PatId, &Pat)> {
        self.pats.iter()
    }
-    pub fn syntax_mapping(&self, db: &impl HirDatabase) -> Arc<BodySyntaxMapping> {
-        db.body_syntax_mapping(self.owner)
-    }
 }
 // needs arbitrary_self_types to be a method... or maybe move to the def?
@@ -119,33 +114,29 @@ impl Index<PatId> for Body {
    }
 }
-impl BodySyntaxMapping {
+impl BodySourceMap {
    pub fn expr_syntax(&self, expr: ExprId) -> Option<SyntaxNodePtr> {
-        self.expr_syntax_mapping_back.get(expr).cloned()
+        self.expr_map_back.get(expr).cloned()
    }
    pub fn syntax_expr(&self, ptr: SyntaxNodePtr) -> Option<ExprId> {
-        self.expr_syntax_mapping.get(&ptr).cloned()
+        self.expr_map.get(&ptr).cloned()
    }
    pub fn node_expr(&self, node: &ast::Expr) -> Option<ExprId> {
-        self.expr_syntax_mapping.get(&SyntaxNodePtr::new(node.syntax())).cloned()
+        self.expr_map.get(&SyntaxNodePtr::new(node.syntax())).cloned()
    }
    pub fn pat_syntax(&self, pat: PatId) -> Option<SyntaxNodePtr> {
-        self.pat_syntax_mapping_back.get(pat).cloned()
+        self.pat_map_back.get(pat).cloned()
    }
    pub fn syntax_pat(&self, ptr: SyntaxNodePtr) -> Option<PatId> {
-        self.pat_syntax_mapping.get(&ptr).cloned()
+        self.pat_map.get(&ptr).cloned()
    }
    pub fn node_pat(&self, node: &ast::Pat) -> Option<PatId> {
-        self.pat_syntax_mapping.get(&SyntaxNodePtr::new(node.syntax())).cloned()
+        self.pat_map.get(&SyntaxNodePtr::new(node.syntax())).cloned()
-    }
-    pub fn body(&self) -> &Arc<Body> {
-        &self.body
    }
 }
@@ -467,18 +458,11 @@ impl Pat {
 // Queries
-pub(crate) fn body_hir(db: &impl HirDatabase, func: Function) -> Arc<Body> {
-    Arc::clone(&body_syntax_mapping(db, func).body)
-}
 struct ExprCollector {
    owner: Function,
    exprs: Arena<ExprId, Expr>,
    pats: Arena<PatId, Pat>,
-    expr_syntax_mapping: FxHashMap<SyntaxNodePtr, ExprId>,
+    source_map: BodySourceMap,
-    expr_syntax_mapping_back: ArenaMap<ExprId, SyntaxNodePtr>,
-    pat_syntax_mapping: FxHashMap<SyntaxNodePtr, PatId>,
-    pat_syntax_mapping_back: ArenaMap<PatId, SyntaxNodePtr>,
    params: Vec<PatId>,
    body_expr: Option<ExprId>,
 }
@@ -489,10 +473,7 @@ impl ExprCollector {
            owner,
            exprs: Arena::default(),
            pats: Arena::default(),
-            expr_syntax_mapping: FxHashMap::default(),
+            source_map: BodySourceMap::default(),
-            expr_syntax_mapping_back: ArenaMap::default(),
-            pat_syntax_mapping: FxHashMap::default(),
-            pat_syntax_mapping_back: ArenaMap::default(),
            params: Vec::new(),
            body_expr: None,
        }
@@ -500,15 +481,15 @@ impl ExprCollector {
    fn alloc_expr(&mut self, expr: Expr, syntax_ptr: SyntaxNodePtr) -> ExprId {
        let id = self.exprs.alloc(expr);
-        self.expr_syntax_mapping.insert(syntax_ptr, id);
+        self.source_map.expr_map.insert(syntax_ptr, id);
-        self.expr_syntax_mapping_back.insert(id, syntax_ptr);
+        self.source_map.expr_map_back.insert(id, syntax_ptr);
        id
    }
    fn alloc_pat(&mut self, pat: Pat, syntax_ptr: SyntaxNodePtr) -> PatId {
        let id = self.pats.alloc(pat);
-        self.pat_syntax_mapping.insert(syntax_ptr, id);
+        self.source_map.pat_map.insert(syntax_ptr, id);
-        self.pat_syntax_mapping_back.insert(id, syntax_ptr);
+        self.source_map.pat_map_back.insert(id, syntax_ptr);
        id
    }
@@ -639,7 +620,7 @@ impl ExprCollector {
            ast::ExprKind::ParenExpr(e) => {
                let inner = self.collect_expr_opt(e.expr());
                // make the paren expr point to the inner expression as well
-                self.expr_syntax_mapping.insert(syntax_ptr, inner);
+                self.source_map.expr_map.insert(syntax_ptr, inner);
                inner
            }
            ast::ExprKind::ReturnExpr(e) => {
@@ -660,9 +641,11 @@ impl ExprCollector {
                            } else if let Some(nr) = field.name_ref() {
                                // field shorthand
                                let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(nr)));
-                                self.expr_syntax_mapping
+                                self.source_map
+                                    .expr_map
                                    .insert(SyntaxNodePtr::new(nr.syntax()), id);
-                                self.expr_syntax_mapping_back
+                                self.source_map
+                                    .expr_map_back
                                    .insert(id, SyntaxNodePtr::new(nr.syntax()));
                                id
                            } else {
@@ -910,7 +893,7 @@ impl ExprCollector {
        self.body_expr = Some(body);
    }
-    fn into_body_syntax_mapping(self) -> BodySyntaxMapping {
+    fn finish(self) -> (Body, BodySourceMap) {
        let body = Body {
            owner: self.owner,
            exprs: self.exprs,
@@ -918,28 +901,30 @@ impl ExprCollector {
            params: self.params,
            body_expr: self.body_expr.expect("A body should have been collected"),
        };
-        BodySyntaxMapping {
+        (body, self.source_map)
-            body: Arc::new(body),
-            expr_syntax_mapping: self.expr_syntax_mapping,
-            expr_syntax_mapping_back: self.expr_syntax_mapping_back,
-            pat_syntax_mapping: self.pat_syntax_mapping,
-            pat_syntax_mapping_back: self.pat_syntax_mapping_back,
-        }
    }
 }
-pub(crate) fn body_syntax_mapping(db: &impl HirDatabase, func: Function) -> Arc<BodySyntaxMapping> {
+pub(crate) fn body_with_source_map_query(
+    db: &impl HirDatabase,
+    func: Function,
+) -> (Arc<Body>, Arc<BodySourceMap>) {
    let mut collector = ExprCollector::new(func);
    // TODO: consts, etc.
    collector.collect_fn_body(&func.source(db).1);
-    Arc::new(collector.into_body_syntax_mapping())
+    let (body, source_map) = collector.finish();
+    (Arc::new(body), Arc::new(source_map))
+}
+pub(crate) fn body_hir_query(db: &impl HirDatabase, func: Function) -> Arc<Body> {
+    db.body_with_source_map(func).0
 }
 #[cfg(test)]
-pub(crate) fn collect_fn_body_syntax(function: Function, node: &ast::FnDef) -> BodySyntaxMapping {
+fn collect_fn_body_syntax(function: Function, node: &ast::FnDef) -> (Body, BodySourceMap) {
    let mut collector = ExprCollector::new(function);
    collector.collect_fn_body(node);
-    collector.into_body_syntax_mapping()
+    collector.finish()
 }
diff --git a/crates/ra_hir/src/expr/scope.rs b/crates/ra_hir/src/expr/scope.rs
index bb8d50db8..81fbc509e 100644
--- a/crates/ra_hir/src/expr/scope.rs
+++ b/crates/ra_hir/src/expr/scope.rs
@@ -11,7 +11,7 @@ use ra_arena::{Arena, RawId, impl_arena_id};
 use crate::{
    Name, AsName, Function,
-    expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySyntaxMapping},
+    expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySourceMap},
    HirDatabase,
 };
@@ -108,8 +108,8 @@ impl ExprScopes {
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ScopesWithSyntaxMapping {
+pub struct ScopesWithSourceMap {
-    pub syntax_mapping: Arc<BodySyntaxMapping>,
+    pub source_map: Arc<BodySourceMap>,
    pub scopes: Arc<ExprScopes>,
 }
@@ -129,7 +129,7 @@ impl ScopeEntryWithSyntax {
    }
 }
-impl ScopesWithSyntaxMapping {
+impl ScopesWithSourceMap {
    fn scope_chain<'a>(&'a self, node: &SyntaxNode) -> impl Iterator<Item = ScopeId> + 'a {
        generate(self.scope_for(node), move |&scope| self.scopes.scopes[scope].parent)
    }
@@ -138,7 +138,7 @@ impl ScopesWithSyntaxMapping {
        self.scopes
            .scope_for
            .iter()
-            .filter_map(|(id, scope)| Some((self.syntax_mapping.expr_syntax(*id)?, scope)))
+            .filter_map(|(id, scope)| Some((self.source_map.expr_syntax(*id)?, scope)))
            // find containing scope
            .min_by_key(|(ptr, _scope)| {
                (!(ptr.range().start() <= offset && offset <= ptr.range().end()), ptr.range().len())
@@ -155,7 +155,7 @@ impl ScopesWithSyntaxMapping {
            .scopes
            .scope_for
            .iter()
-            .filter_map(|(id, scope)| Some((self.syntax_mapping.expr_syntax(*id)?, scope)))
+            .filter_map(|(id, scope)| Some((self.source_map.expr_syntax(*id)?, scope)))
            .map(|(ptr, scope)| (ptr.range(), scope))
            .filter(|(range, _)| range.start() <= offset && range.is_subrange(&r) && *range != r);
@@ -185,7 +185,7 @@ impl ScopesWithSyntaxMapping {
        ret.and_then(|entry| {
            Some(ScopeEntryWithSyntax {
                name: entry.name().clone(),
-                ptr: self.syntax_mapping.pat_syntax(entry.pat())?,
+                ptr: self.source_map.pat_syntax(entry.pat())?,
            })
        })
    }
@@ -211,7 +211,7 @@ impl ScopesWithSyntaxMapping {
    pub fn scope_for(&self, node: &SyntaxNode) -> Option<ScopeId> {
        node.ancestors()
            .map(SyntaxNodePtr::new)
-            .filter_map(|ptr| self.syntax_mapping.syntax_expr(ptr))
+            .filter_map(|ptr| self.source_map.syntax_expr(ptr))
            .find_map(|it| self.scopes.scope_for(it))
    }
 }
@@ -316,12 +316,10 @@ mod tests {
        let marker: &ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
        let fn_def: &ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
        let irrelevant_function = Function { id: crate::ids::FunctionId::from_raw(0.into()) };
-        let body_hir = expr::collect_fn_body_syntax(irrelevant_function, fn_def);
+        let (body, source_map) = expr::collect_fn_body_syntax(irrelevant_function, fn_def);
-        let scopes = ExprScopes::new(Arc::clone(body_hir.body()));
+        let scopes = ExprScopes::new(Arc::new(body));
-        let scopes = ScopesWithSyntaxMapping {
+        let scopes =
-            scopes: Arc::new(scopes),
+            ScopesWithSourceMap { scopes: Arc::new(scopes), source_map: Arc::new(source_map) };
-            syntax_mapping: Arc::new(body_hir),
-        };
        let actual = scopes
            .scope_chain(marker.syntax())
            .flat_map(|scope| scopes.scopes.entries(scope))
@@ -417,12 +415,10 @@ mod tests {
        let name_ref: &ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
        let irrelevant_function = Function { id: crate::ids::FunctionId::from_raw(0.into()) };
-        let body_hir = expr::collect_fn_body_syntax(irrelevant_function, fn_def);
+        let (body, source_map) = expr::collect_fn_body_syntax(irrelevant_function, fn_def);
-        let scopes = ExprScopes::new(Arc::clone(body_hir.body()));
+        let scopes = ExprScopes::new(Arc::new(body));
-        let scopes = ScopesWithSyntaxMapping {
+        let scopes =
-            scopes: Arc::new(scopes),
+            ScopesWithSourceMap { scopes: Arc::new(scopes), source_map: Arc::new(source_map) };
-            syntax_mapping: Arc::new(body_hir),
-        };
        let local_name_entry = scopes.resolve_local_name(name_ref).unwrap();
        let local_name = local_name_entry.ptr();
        assert_eq!(local_name.range(), expected_name.syntax().range());
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index edc1b4f57..a6e744ea7 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -60,7 +60,7 @@ pub use self::{
    impl_block::{ImplBlock, ImplItem},
    docs::{Docs, Documentation},
    adt::AdtDef,
-    expr::{ExprScopes, ScopesWithSyntaxMapping, ScopeEntryWithSyntax},
+    expr::{ExprScopes, ScopesWithSourceMap, ScopeEntryWithSyntax},
    resolve::{Resolver, Resolution},
 };
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index ac390c5db..73919ee37 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -481,7 +481,7 @@ impl ItemMap {
        let module_tree = db.module_tree(krate);
        let input = module_tree
            .modules()
-            .map(|module_id| (module_id, db.lower_module_module(Module { krate, module_id })))
+            .map(|module_id| (module_id, db.lower_module(Module { krate, module_id })))
            .collect::<FxHashMap<_, _>>();
        let resolver = Resolver::new(db, &input, krate);
diff --git a/crates/ra_hir/src/nameres/lower.rs b/crates/ra_hir/src/nameres/lower.rs
index 2bc3eb60c..56262ad6d 100644
--- a/crates/ra_hir/src/nameres/lower.rs
+++ b/crates/ra_hir/src/nameres/lower.rs
@@ -60,21 +60,14 @@ impl ImportSourceMap {
 }
 impl LoweredModule {
-    pub(crate) fn lower_module_module_query(
+    pub(crate) fn lower_module_query(
        db: &impl PersistentHirDatabase,
        module: Module,
    ) -> Arc<LoweredModule> {
-        db.lower_module(module).0
+        db.lower_module_with_source_map(module).0
-    }
-    pub(crate) fn lower_module_source_map_query(
-        db: &impl PersistentHirDatabase,
-        module: Module,
-    ) -> Arc<ImportSourceMap> {
-        db.lower_module(module).1
    }
-    pub(crate) fn lower_module_query(
+    pub(crate) fn lower_module_with_source_map_query(
        db: &impl PersistentHirDatabase,
        module: Module,
    ) -> (Arc<LoweredModule>, Arc<ImportSourceMap>) {
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 625a2ce45..ea20cd15a 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -157,7 +157,7 @@ pub fn macro_symbols(db: &impl HirDatabase, file_id: FileId) -> Vec<(SmolStr, Te
        Some(it) => it,
        None => return Vec::new(),
    };
-    let items = db.lower_module_module(module);
+    let items = db.lower_module(module);
    let mut res = Vec::new();
    for macro_call_id in items
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index e505c86e3..bad811a56 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -54,7 +54,7 @@ pub enum Ty {
    /// The pointee of an array slice.  Written as `[T]`.
    Slice(Arc<Ty>),
-    // An array with the given length. Written as `[T; n]`.
+    /// An array with the given length. Written as `[T; n]`.
    Array(Arc<Ty>),
    /// A raw pointer. Written as `*mut T` or `*const T`
@@ -97,36 +97,12 @@ pub enum Ty {
    /// ```
    FnPtr(Arc<FnSig>),
-    // rustc has a separate type for each function, which just coerces to the
-    // above function pointer type. Once we implement generics, we will probably
-    // need this as well.
-    // A trait, defined with `dyn Trait`.
-    // Dynamic(),
-    // The anonymous type of a closure. Used to represent the type of
-    // `|a| a`.
-    // Closure(DefId, ClosureSubsts<'tcx>),
-    // The anonymous type of a generator. Used to represent the type of
-    // `|a| yield a`.
-    // Generator(DefId, GeneratorSubsts<'tcx>, hir::GeneratorMovability),
-    // A type representing the types stored inside a generator.
-    // This should only appear in GeneratorInteriors.
-    // GeneratorWitness(Binder<&'tcx List<Ty<'tcx>>>),
    /// The never type `!`.
    Never,
    /// A tuple type.  For example, `(i32, bool)`.
    Tuple(Arc<[Ty]>),
-    // The projection of an associated type.  For example,
-    // `<T as Trait<..>>::N`.pub
-    // Projection(ProjectionTy),
-    // Opaque (`impl Trait`) type found in a return type.
-    // Opaque(DefId, Substs),
    /// A type parameter; for example, `T` in `fn f<T>(x: T) {}
    Param {
        /// The index of the parameter (starting with parameters from the
@@ -304,9 +280,6 @@ impl Ty {
                if (idx as usize) < substs.0.len() {
                    substs.0[idx as usize].clone()
                } else {
-                    // TODO: does this indicate a bug? i.e. should we always
-                    // have substs for all type params? (they might contain the
-                    // params themselves again...)
                    Ty::Param { idx, name }
                }
            }
@@ -366,7 +339,7 @@ impl fmt::Display for Ty {
                Ok(())
            }
            Ty::Param { name, .. } => write!(f, "{}", name),
-            Ty::Unknown => write!(f, "[unknown]"),
+            Ty::Unknown => write!(f, "{{unknown}}"),
            Ty::Infer(..) => write!(f, "_"),
        }
    }
diff --git a/crates/ra_hir/src/ty/snapshots/tests__bug_484.snap b/crates/ra_hir/src/ty/snapshots/tests__bug_484.snap
deleted file mode 100644
index 28f57623d..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__bug_484.snap
+++ /dev/null
@@ -1,12 +0,0 @@
---
-created: "2019-01-22T14:44:59.880187500+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[11; 37) '{    l... {}; }': ()
-[20; 21) 'x': ()
-[24; 34) 'if true {}': ()
-[27; 31) 'true': bool
-[32; 34) '{}': ()
diff --git a/crates/ra_hir/src/ty/snapshots/tests__bug_585.snap b/crates/ra_hir/src/ty/snapshots/tests__bug_585.snap
deleted file mode 100644
index e7b42e413..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__bug_585.snap
+++ /dev/null
@@ -1,15 +0,0 @@
---
-created: "2019-01-22T14:44:59.880187500+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[11; 89) '{     ...   } }': ()
-[17; 21) 'X {}': [unknown]
-[27; 87) 'match ...     }': ()
-[33; 34) 'x': [unknown]
-[45; 52) 'A::B {}': [unknown]
-[56; 58) '()': ()
-[68; 74) 'A::Y()': [unknown]
-[78; 80) '()': ()
diff --git a/crates/ra_hir/src/ty/snapshots/tests__bug_651.snap b/crates/ra_hir/src/ty/snapshots/tests__bug_651.snap
deleted file mode 100644
index d23d3f139..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__bug_651.snap
+++ /dev/null
@@ -1,13 +0,0 @@
---
-created: "2019-01-25T20:31:47.275112244+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[11; 41) '{     ...+ y; }': ()
-[21; 22) 'y': i32
-[25; 27) '92': i32
-[33; 34) '1': i32
-[33; 38) '1 + y': i32
-[37; 38) 'y': i32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap
deleted file mode 100644
index 48c83cbb2..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap
+++ /dev/null
@@ -1,32 +0,0 @@
---
-created: "2019-01-28T21:58:55.559331849+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[68; 289) '{     ...  d; }': ()
-[78; 79) 'e': E
-[82; 95) 'E::A { x: 3 }': E
-[92; 93) '3': usize
-[106; 113) 'S(y, z)': S
-[108; 109) 'y': u32
-[111; 112) 'z': E
-[116; 119) 'foo': S
-[129; 148) 'E::A {..._var }': E
-[139; 146) 'new_var': usize
-[151; 152) 'e': E
-[159; 245) 'match ...     }': usize
-[165; 166) 'e': E
-[177; 187) 'E::A { x }': E
-[184; 185) 'x': usize
-[191; 192) 'x': usize
-[202; 206) 'E::B': E
-[210; 213) 'foo': bool
-[217; 218) '1': usize
-[228; 232) 'E::B': E
-[236; 238) '10': usize
-[256; 275) 'ref d ...{ .. }': &E
-[264; 275) 'E::A { .. }': E
-[278; 279) 'e': E
-[285; 286) 'd': &E
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap
deleted file mode 100644
index 042248c35..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap
+++ /dev/null
@@ -1,65 +0,0 @@
---
-created: "2019-01-30T20:08:05.185312835+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[9; 10) 'x': &str
-[18; 19) 'y': isize
-[28; 324) '{     ... 3]; }': ()
-[38; 39) 'a': [&str]
-[42; 45) '[x]': [&str]
-[43; 44) 'x': &str
-[55; 56) 'b': [[&str]]
-[59; 65) '[a, a]': [[&str]]
-[60; 61) 'a': [&str]
-[63; 64) 'a': [&str]
-[75; 76) 'c': [[[&str]]]
-[79; 85) '[b, b]': [[[&str]]]
-[80; 81) 'b': [[&str]]
-[83; 84) 'b': [[&str]]
-[96; 97) 'd': [isize]
-[100; 112) '[y, 1, 2, 3]': [isize]
-[101; 102) 'y': isize
-[104; 105) '1': isize
-[107; 108) '2': isize
-[110; 111) '3': isize
-[122; 123) 'd': [isize]
-[126; 138) '[1, y, 2, 3]': [isize]
-[127; 128) '1': isize
-[130; 131) 'y': isize
-[133; 134) '2': isize
-[136; 137) '3': isize
-[148; 149) 'e': [isize]
-[152; 155) '[y]': [isize]
-[153; 154) 'y': isize
-[165; 166) 'f': [[isize]]
-[169; 175) '[d, d]': [[isize]]
-[170; 171) 'd': [isize]
-[173; 174) 'd': [isize]
-[185; 186) 'g': [[isize]]
-[189; 195) '[e, e]': [[isize]]
-[190; 191) 'e': [isize]
-[193; 194) 'e': [isize]
-[206; 207) 'h': [i32]
-[210; 216) '[1, 2]': [i32]
-[211; 212) '1': i32
-[214; 215) '2': i32
-[226; 227) 'i': [&str]
-[230; 240) '["a", "b"]': [&str]
-[231; 234) '"a"': &str
-[236; 239) '"b"': &str
-[251; 252) 'b': [[&str]]
-[255; 265) '[a, ["b"]]': [[&str]]
-[256; 257) 'a': [&str]
-[259; 264) '["b"]': [&str]
-[260; 263) '"b"': &str
-[275; 276) 'x': [u8]
-[288; 290) '[]': [u8]
-[300; 301) 'z': &[u8]
-[311; 321) '&[1, 2, 3]': &[u8]
-[312; 321) '[1, 2, 3]': [u8]
-[313; 314) '1': u8
-[316; 317) '2': u8
-[319; 320) '3': u8
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_const.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_associated_const.snap
deleted file mode 100644
index 51f3fd4c0..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_const.snap
+++ /dev/null
@@ -1,14 +0,0 @@
---
-created: "2019-02-25T08:36:33.885804400Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[227; 305) '{     ...:ID; }': ()
-[237; 238) 'x': u32
-[241; 252) 'Struct::FOO': u32
-[262; 263) 'y': u32
-[266; 275) 'Enum::BAR': u32
-[285; 286) 'z': u32
-[289; 302) 'TraitTest::ID': u32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_enum.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_enum.snap
deleted file mode 100644
index 8f27af88c..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_enum.snap
+++ /dev/null
@@ -1,20 +0,0 @@
---
-created: "2019-02-20T11:04:56.553382800Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[48; 68) '{     ...     }': A
-[58; 62) 'A::B': A
-[89; 109) '{     ...     }': A
-[99; 103) 'A::C': A
-[122; 179) '{     ...  c; }': ()
-[132; 133) 'a': A
-[136; 140) 'A::b': fn b() -> A
-[136; 142) 'A::b()': A
-[148; 149) 'a': A
-[159; 160) 'c': A
-[163; 167) 'A::c': fn c() -> A
-[163; 169) 'A::c()': A
-[175; 176) 'c': A
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_generics.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_generics.snap
deleted file mode 100644
index 44694dfdb..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_generics.snap
+++ /dev/null
@@ -1,16 +0,0 @@
---
-created: "2019-02-23T21:58:35.844769207Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[64; 67) 'val': T
-[82; 109) '{     ...     }': Gen<T>
-[92; 103) 'Gen { val }': Gen<T>
-[98; 101) 'val': T
-[123; 155) '{     ...32); }': ()
-[133; 134) 'a': Gen<u32>
-[137; 146) 'Gen::make': fn make<u32>(T) -> Gen<T>
-[137; 152) 'Gen::make(0u32)': Gen<u32>
-[147; 151) '0u32': u32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_struct.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_struct.snap
deleted file mode 100644
index 29ca9b0ea..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_struct.snap
+++ /dev/null
@@ -1,16 +0,0 @@
---
-created: "2019-02-20T11:04:56.553382800Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[50; 76) '{     ...     }': A
-[60; 70) 'A { x: 0 }': A
-[67; 68) '0': u32
-[89; 123) '{     ...a.x; }': ()
-[99; 100) 'a': A
-[103; 109) 'A::new': fn new() -> A
-[103; 111) 'A::new()': A
-[117; 118) 'a': A
-[117; 120) 'a.x': u32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_with_modules.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_with_modules.snap
deleted file mode 100644
index 6584bef39..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_with_modules.snap
+++ /dev/null
@@ -1,23 +0,0 @@
---
-created: "2019-02-21T08:55:53.926725400Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[56; 64) '{ A {} }': A
-[58; 62) 'A {}': A
-[126; 132) '{ 99 }': u32
-[128; 130) '99': u32
-[202; 210) '{ C {} }': C
-[204; 208) 'C {}': C
-[241; 325) '{     ...g(); }': ()
-[251; 252) 'x': A
-[255; 266) 'a::A::thing': fn thing() -> A
-[255; 268) 'a::A::thing()': A
-[278; 279) 'y': u32
-[282; 293) 'b::B::thing': fn thing() -> u32
-[282; 295) 'b::B::thing()': u32
-[305; 306) 'z': C
-[309; 320) 'c::C::thing': fn thing() -> C
-[309; 322) 'c::C::thing()': C
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_backwards.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_backwards.snap
deleted file mode 100644
index f5840a934..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_backwards.snap
+++ /dev/null
@@ -1,27 +0,0 @@
---
-created: "2019-01-26T17:46:03.842478456+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[14; 15) 'x': u32
-[22; 24) '{}': ()
-[78; 231) '{     ...t &c }': &mut &f64
-[88; 89) 'a': u32
-[92; 108) 'unknow...nction': [unknown]
-[92; 110) 'unknow...tion()': u32
-[116; 125) 'takes_u32': fn takes_u32(u32) -> ()
-[116; 128) 'takes_u32(a)': ()
-[126; 127) 'a': u32
-[138; 139) 'b': i32
-[142; 158) 'unknow...nction': [unknown]
-[142; 160) 'unknow...tion()': i32
-[166; 184) 'S { i3...d: b }': S
-[181; 182) 'b': i32
-[194; 195) 'c': f64
-[198; 214) 'unknow...nction': [unknown]
-[198; 216) 'unknow...tion()': f64
-[222; 229) '&mut &c': &mut &f64
-[227; 229) '&c': &f64
-[228; 229) 'c': f64
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_basics.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_basics.snap
deleted file mode 100644
index 4b0863558..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_basics.snap
+++ /dev/null
@@ -1,20 +0,0 @@
---
-created: "2019-01-22T14:44:59.880187500+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[9; 10) 'a': u32
-[17; 18) 'b': isize
-[27; 28) 'c': !
-[33; 34) 'd': &str
-[42; 121) '{     ...f32; }': ()
-[48; 49) 'a': u32
-[55; 56) 'b': isize
-[62; 63) 'c': !
-[69; 70) 'd': &str
-[76; 82) '1usize': usize
-[88; 94) '1isize': isize
-[100; 106) '"test"': &str
-[112; 118) '1.0f32': f32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_binary_op.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_binary_op.snap
deleted file mode 100644
index 80ffe6e11..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_binary_op.snap
+++ /dev/null
@@ -1,57 +0,0 @@
---
-created: "2019-02-18T07:03:52.524808301Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[6; 7) 'x': bool
-[22; 34) '{     0i32 }': i32
-[28; 32) '0i32': i32
-[54; 370) '{     ... < 3 }': bool
-[64; 65) 'x': bool
-[68; 69) 'a': bool
-[68; 74) 'a && b': bool
-[73; 74) 'b': bool
-[84; 85) 'y': bool
-[88; 92) 'true': bool
-[88; 101) 'true || false': bool
-[96; 101) 'false': bool
-[111; 112) 'z': bool
-[115; 116) 'x': bool
-[115; 121) 'x == y': bool
-[120; 121) 'y': bool
-[131; 132) 't': bool
-[135; 136) 'x': bool
-[135; 141) 'x != y': bool
-[140; 141) 'y': bool
-[151; 162) 'minus_forty': isize
-[172; 180) '-40isize': isize
-[173; 180) '40isize': isize
-[190; 191) 'h': bool
-[194; 205) 'minus_forty': isize
-[194; 216) 'minus_...ONST_2': bool
-[209; 216) 'CONST_2': isize
-[226; 227) 'c': i32
-[230; 231) 'f': fn f(bool) -> i32
-[230; 239) 'f(z || y)': i32
-[230; 243) 'f(z || y) + 5': i32
-[232; 233) 'z': bool
-[232; 238) 'z || y': bool
-[237; 238) 'y': bool
-[242; 243) '5': i32
-[253; 254) 'd': [unknown]
-[257; 258) 'b': [unknown]
-[268; 269) 'g': ()
-[272; 283) 'minus_forty': isize
-[272; 288) 'minus_...y ^= i': ()
-[287; 288) 'i': isize
-[298; 301) 'ten': usize
-[311; 313) '10': usize
-[323; 336) 'ten_is_eleven': bool
-[339; 342) 'ten': usize
-[339; 354) 'ten == some_num': bool
-[346; 354) 'some_num': usize
-[361; 364) 'ten': usize
-[361; 368) 'ten < 3': bool
-[367; 368) '3': usize
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_const.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_const.snap
deleted file mode 100644
index a5eba3980..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_const.snap
+++ /dev/null
@@ -1,14 +0,0 @@
---
-created: "2019-02-25T07:26:34.115351100Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[95; 213) '{     ...NST; }': ()
-[138; 139) 'x': [unknown]
-[142; 153) 'LOCAL_CONST': [unknown]
-[163; 164) 'z': u32
-[167; 179) 'GLOBAL_CONST': u32
-[189; 191) 'id': u32
-[194; 210) 'Foo::A..._CONST': u32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_enum.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_enum.snap
deleted file mode 100644
index bc8b84272..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_enum.snap
+++ /dev/null
@@ -1,11 +0,0 @@
---
-created: "2019-01-22T14:44:59.880187500+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[48; 82) '{   E:...:V2; }': ()
-[52; 70) 'E::V1 ...d: 1 }': E
-[67; 68) '1': u32
-[74; 79) 'E::V2': E
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_field_autoderef.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_field_autoderef.snap
deleted file mode 100644
index f092fd319..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_field_autoderef.snap
+++ /dev/null
@@ -1,50 +0,0 @@
---
-created: "2019-01-22T14:44:59.955954900+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[44; 45) 'a': A
-[50; 213) '{     ...5.b; }': ()
-[60; 62) 'a1': A
-[65; 66) 'a': A
-[72; 74) 'a1': A
-[72; 76) 'a1.b': B
-[86; 88) 'a2': &A
-[91; 93) '&a': &A
-[92; 93) 'a': A
-[99; 101) 'a2': &A
-[99; 103) 'a2.b': B
-[113; 115) 'a3': &mut A
-[118; 124) '&mut a': &mut A
-[123; 124) 'a': A
-[130; 132) 'a3': &mut A
-[130; 134) 'a3.b': B
-[144; 146) 'a4': &&&&&&&A
-[149; 157) '&&&&&&&a': &&&&&&&A
-[150; 157) '&&&&&&a': &&&&&&A
-[151; 157) '&&&&&a': &&&&&A
-[152; 157) '&&&&a': &&&&A
-[153; 157) '&&&a': &&&A
-[154; 157) '&&a': &&A
-[155; 157) '&a': &A
-[156; 157) 'a': A
-[163; 165) 'a4': &&&&&&&A
-[163; 167) 'a4.b': B
-[177; 179) 'a5': &mut &&mut &&mut A
-[182; 200) '&mut &...&mut a': &mut &&mut &&mut A
-[187; 200) '&&mut &&mut a': &&mut &&mut A
-[188; 200) '&mut &&mut a': &mut &&mut A
-[193; 200) '&&mut a': &&mut A
-[194; 200) '&mut a': &mut A
-[199; 200) 'a': A
-[206; 208) 'a5': &mut &&mut &&mut A
-[206; 210) 'a5.b': B
-[224; 226) 'a1': *const A
-[238; 240) 'a2': *mut A
-[250; 273) '{     ...2.b; }': ()
-[256; 258) 'a1': *const A
-[256; 260) 'a1.b': B
-[266; 268) 'a2': *mut A
-[266; 270) 'a2.b': B
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap
deleted file mode 100644
index 91c48897c..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap
+++ /dev/null
@@ -1,21 +0,0 @@
---
-created: "2019-01-27T14:52:29.934503829+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[10; 11) 't': T
-[21; 26) '{ t }': T
-[23; 24) 't': T
-[38; 98) '{     ...(1); }': ()
-[44; 46) 'id': fn id<u32>(T) -> T
-[44; 52) 'id(1u32)': u32
-[47; 51) '1u32': u32
-[58; 68) 'id::<i128>': fn id<i128>(T) -> T
-[58; 71) 'id::<i128>(1)': i128
-[69; 70) '1': i128
-[81; 82) 'x': u64
-[90; 92) 'id': fn id<u64>(T) -> T
-[90; 95) 'id(1)': u64
-[93; 94) '1': u64
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap
deleted file mode 100644
index d1ce87b0a..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap
+++ /dev/null
@@ -1,36 +0,0 @@
---
-created: "2019-02-16T20:53:59.655361804Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[53; 57) 'self': A<T2>
-[65; 87) '{     ...     }': T2
-[75; 79) 'self': A<T2>
-[75; 81) 'self.x': T2
-[99; 100) 't': T
-[110; 115) '{ t }': T
-[112; 113) 't': T
-[135; 261) '{     ....x() }': i128
-[146; 147) 'x': i128
-[150; 151) '1': i128
-[162; 163) 'y': i128
-[166; 168) 'id': fn id<i128>(T) -> T
-[166; 171) 'id(x)': i128
-[169; 170) 'x': i128
-[182; 183) 'a': A<i128>
-[186; 200) 'A { x: id(y) }': A<i128>
-[193; 195) 'id': fn id<i128>(T) -> T
-[193; 198) 'id(y)': i128
-[196; 197) 'y': i128
-[211; 212) 'z': i128
-[215; 217) 'id': fn id<i128>(T) -> T
-[215; 222) 'id(a.x)': i128
-[218; 219) 'a': A<i128>
-[218; 221) 'a.x': i128
-[233; 234) 'b': A<i128>
-[237; 247) 'A { x: z }': A<i128>
-[244; 245) 'z': i128
-[254; 255) 'b': A<i128>
-[254; 259) 'b.x()': i128
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_generics_in_patterns.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_generics_in_patterns.snap
deleted file mode 100644
index fae7ab0dd..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_generics_in_patterns.snap
+++ /dev/null
@@ -1,24 +0,0 @@
---
-created: "2019-01-22T14:44:59.970913200+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[79; 81) 'a1': A<u32>
-[91; 92) 'o': Option<u64>
-[107; 244) '{     ...  }; }': ()
-[117; 128) 'A { x: x2 }': A<u32>
-[124; 126) 'x2': u32
-[131; 133) 'a1': A<u32>
-[143; 161) 'A::<i6...: x3 }': A<i64>
-[157; 159) 'x3': i64
-[164; 174) 'A { x: 1 }': A<i64>
-[171; 172) '1': i64
-[180; 241) 'match ...     }': u64
-[186; 187) 'o': Option<u64>
-[198; 213) 'Option::Some(t)': Option<u64>
-[211; 212) 't': u64
-[217; 218) 't': u64
-[228; 229) '_': Option<u64>
-[233; 234) '1': u64
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_impl_generics.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_impl_generics.snap
deleted file mode 100644
index 44f00a52e..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_impl_generics.snap
+++ /dev/null
@@ -1,39 +0,0 @@
---
-created: "2019-02-16T21:58:14.029368845Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[74; 78) 'self': A<X, Y>
-[85; 107) '{     ...     }': X
-[95; 99) 'self': A<X, Y>
-[95; 101) 'self.x': X
-[117; 121) 'self': A<X, Y>
-[128; 150) '{     ...     }': Y
-[138; 142) 'self': A<X, Y>
-[138; 144) 'self.y': Y
-[163; 167) 'self': A<X, Y>
-[169; 170) 't': T
-[188; 223) '{     ...     }': (X, Y, T)
-[198; 217) '(self.....y, t)': (X, Y, T)
-[199; 203) 'self': A<X, Y>
-[199; 205) 'self.x': X
-[207; 211) 'self': A<X, Y>
-[207; 213) 'self.y': Y
-[215; 216) 't': T
-[245; 342) '{     ...(1); }': ()
-[255; 256) 'a': A<u64, i64>
-[259; 281) 'A { x:...1i64 }': A<u64, i64>
-[266; 270) '1u64': u64
-[275; 279) '1i64': i64
-[287; 288) 'a': A<u64, i64>
-[287; 292) 'a.x()': u64
-[298; 299) 'a': A<u64, i64>
-[298; 303) 'a.y()': i64
-[309; 310) 'a': A<u64, i64>
-[309; 319) 'a.z(1i128)': (u64, i64, i128)
-[313; 318) '1i128': i128
-[325; 326) 'a': A<u64, i64>
-[325; 339) 'a.z::<u128>(1)': (u64, i64, u128)
-[337; 338) '1': u128
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_impl_generics_with_autoderef.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_impl_generics_with_autoderef.snap
deleted file mode 100644
index f609eaf7c..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_impl_generics_with_autoderef.snap
+++ /dev/null
@@ -1,16 +0,0 @@
---
-created: "2019-02-17T13:35:06.385679926Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[78; 82) 'self': &Option<T>
-[98; 100) '{}': ()
-[111; 112) 'o': Option<u32>
-[127; 165) '{     ...f(); }': ()
-[133; 146) '(&o).as_ref()': Option<&u32>
-[134; 136) '&o': &Option<u32>
-[135; 136) 'o': Option<u32>
-[152; 153) 'o': Option<u32>
-[152; 162) 'o.as_ref()': Option<&u32>
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_in_elseif.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_in_elseif.snap
deleted file mode 100644
index 6a435e5cf..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_in_elseif.snap
+++ /dev/null
@@ -1,17 +0,0 @@
---
-created: "2019-01-26T21:36:52.714121185+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[35; 38) 'foo': Foo
-[45; 109) '{     ...   } }': ()
-[51; 107) 'if tru...     }': ()
-[54; 58) 'true': bool
-[59; 67) '{      }': ()
-[73; 107) 'if fal...     }': i32
-[76; 81) 'false': bool
-[82; 107) '{     ...     }': i32
-[92; 95) 'foo': Foo
-[92; 101) 'foo.field': i32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_inherent_method.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_inherent_method.snap
deleted file mode 100644
index b3c706aca..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_inherent_method.snap
+++ /dev/null
@@ -1,25 +0,0 @@
---
-created: "2019-01-22T14:44:59.968918800+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[32; 36) 'self': A
-[38; 39) 'x': u32
-[53; 55) '{}': ()
-[103; 107) 'self': &A
-[109; 110) 'x': u64
-[124; 126) '{}': ()
-[144; 145) 'a': A
-[150; 198) '{     ...(1); }': ()
-[156; 157) 'a': A
-[156; 164) 'a.foo(1)': i32
-[162; 163) '1': u32
-[170; 181) '(&a).bar(1)': i64
-[171; 173) '&a': &A
-[172; 173) 'a': A
-[179; 180) '1': u64
-[187; 188) 'a': A
-[187; 195) 'a.bar(1)': i64
-[193; 194) '1': u64
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_let.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_let.snap
deleted file mode 100644
index 0d085071a..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_let.snap
+++ /dev/null
@@ -1,14 +0,0 @@
---
-created: "2019-01-22T14:44:59.963931700+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[11; 71) '{     ...= b; }': ()
-[21; 22) 'a': isize
-[25; 31) '1isize': isize
-[41; 42) 'b': usize
-[52; 53) '1': usize
-[63; 64) 'c': usize
-[67; 68) 'b': usize
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_literals.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_literals.snap
deleted file mode 100644
index e287a100e..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_literals.snap
+++ /dev/null
@@ -1,19 +0,0 @@
---
-created: "2019-01-22T14:44:59.974903100+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[11; 201) '{     ...o"#; }': ()
-[17; 21) '5i32': i32
-[27; 34) '"hello"': &str
-[40; 48) 'b"bytes"': &[u8]
-[54; 57) ''c'': char
-[63; 67) 'b'b'': u8
-[73; 77) '3.14': f64
-[83; 87) '5000': i32
-[93; 98) 'false': bool
-[104; 108) 'true': bool
-[114; 182) 'r#"   ...    "#': &str
-[188; 198) 'br#"yolo"#': &[u8]
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_nested_generics_crash.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_nested_generics_crash.snap
deleted file mode 100644
index 209454a91..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_nested_generics_crash.snap
+++ /dev/null
@@ -1,12 +0,0 @@
---
-created: "2019-02-11T21:59:04.302375838Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[92; 106) 'query_response': Canonical<QueryResponse<R>>
-[137; 167) '{     ...lue; }': ()
-[143; 164) '&query....value': &QueryResponse<R>
-[144; 158) 'query_response': Canonical<QueryResponse<R>>
-[144; 164) 'query_....value': QueryResponse<R>
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_paths.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_paths.snap
deleted file mode 100644
index afbe2f747..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_paths.snap
+++ /dev/null
@@ -1,16 +0,0 @@
---
-created: "2019-01-26T17:46:03.928773630+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[15; 20) '{ 1 }': u32
-[17; 18) '1': u32
-[48; 53) '{ 1 }': u32
-[50; 51) '1': u32
-[67; 91) '{     ...c(); }': ()
-[73; 74) 'a': fn a() -> u32
-[73; 76) 'a()': u32
-[82; 86) 'b::c': fn c() -> u32
-[82; 88) 'b::c()': u32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_pattern.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_pattern.snap
deleted file mode 100644
index 1da46daf8..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_pattern.snap
+++ /dev/null
@@ -1,54 +0,0 @@
---
-created: "2019-01-22T14:45:00.037734500+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[9; 10) 'x': &i32
-[18; 369) '{     ...o_x; }': ()
-[28; 29) 'y': &i32
-[32; 33) 'x': &i32
-[43; 45) '&z': &i32
-[44; 45) 'z': i32
-[48; 49) 'x': &i32
-[59; 60) 'a': i32
-[63; 64) 'z': i32
-[74; 80) '(c, d)': (i32, &str)
-[75; 76) 'c': i32
-[78; 79) 'd': &str
-[83; 95) '(1, "hello")': (i32, &str)
-[84; 85) '1': i32
-[87; 94) '"hello"': &str
-[102; 152) 'for (e...     }': ()
-[106; 112) '(e, f)': ([unknown], [unknown])
-[107; 108) 'e': [unknown]
-[110; 111) 'f': [unknown]
-[116; 125) 'some_iter': [unknown]
-[126; 152) '{     ...     }': ()
-[140; 141) 'g': [unknown]
-[144; 145) 'e': [unknown]
-[158; 205) 'if let...     }': ()
-[165; 170) '[val]': [unknown]
-[173; 176) 'opt': [unknown]
-[177; 205) '{     ...     }': ()
-[191; 192) 'h': [unknown]
-[195; 198) 'val': [unknown]
-[215; 221) 'lambda': [unknown]
-[224; 256) '|a: u6...b; c }': [unknown]
-[225; 226) 'a': u64
-[233; 234) 'b': u64
-[236; 237) 'c': i32
-[244; 256) '{ a + b; c }': i32
-[246; 247) 'a': u64
-[246; 251) 'a + b': u64
-[250; 251) 'b': u64
-[253; 254) 'c': i32
-[267; 279) 'ref ref_to_x': &&i32
-[282; 283) 'x': &i32
-[293; 302) 'mut mut_x': &i32
-[305; 306) 'x': &i32
-[316; 336) 'ref mu...f_to_x': &mut &i32
-[339; 340) 'x': &i32
-[350; 351) 'k': &mut &i32
-[354; 366) 'mut_ref_to_x': &mut &i32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_refs.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_refs.snap
deleted file mode 100644
index 56931bb3d..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_refs.snap
+++ /dev/null
@@ -1,30 +0,0 @@
---
-created: "2019-01-22T14:45:00.053692600+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[9; 10) 'a': &u32
-[18; 19) 'b': &mut u32
-[31; 32) 'c': *const u32
-[46; 47) 'd': *mut u32
-[59; 150) '{     ... *d; }': ()
-[65; 66) 'a': &u32
-[72; 74) '*a': u32
-[73; 74) 'a': &u32
-[80; 82) '&a': &&u32
-[81; 82) 'a': &u32
-[88; 94) '&mut a': &mut &u32
-[93; 94) 'a': &u32
-[100; 101) 'b': &mut u32
-[107; 109) '*b': u32
-[108; 109) 'b': &mut u32
-[115; 117) '&b': &&mut u32
-[116; 117) 'b': &mut u32
-[123; 124) 'c': *const u32
-[130; 132) '*c': u32
-[131; 132) 'c': *const u32
-[138; 139) 'd': *mut u32
-[145; 147) '*d': u32
-[146; 147) 'd': *mut u32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_self.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_self.snap
deleted file mode 100644
index 5c927f5c1..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_self.snap
+++ /dev/null
@@ -1,17 +0,0 @@
---
-created: "2019-02-04T19:40:48.826936500+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[34; 38) 'self': &S
-[40; 61) '{     ...     }': ()
-[50; 54) 'self': &S
-[75; 79) 'self': &S
-[88; 109) '{     ...     }': ()
-[98; 102) 'self': &S
-[133; 153) '{     ...     }': S
-[143; 147) 'S {}': S
-[177; 200) '{     ...     }': S
-[187; 194) 'Self {}': S
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_static.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_static.snap
deleted file mode 100644
index 5d90f56ed..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_static.snap
+++ /dev/null
@@ -1,16 +0,0 @@
---
-created: "2019-02-25T08:20:17.807316Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[85; 280) '{     ...MUT; }': ()
-[173; 174) 'x': [unknown]
-[177; 189) 'LOCAL_STATIC': [unknown]
-[199; 200) 'y': [unknown]
-[203; 219) 'LOCAL_...IC_MUT': [unknown]
-[229; 230) 'z': u32
-[233; 246) 'GLOBAL_STATIC': u32
-[256; 257) 'w': u32
-[260; 277) 'GLOBAL...IC_MUT': u32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_1.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_1.snap
deleted file mode 100644
index 4b99788e4..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_1.snap
+++ /dev/null
@@ -1,13 +0,0 @@
---
-created: "2019-02-09T16:56:24.803326529Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[54; 139) '{     ...   } }': ()
-[60; 137) 'match ...     }': ()
-[66; 83) 'someth...nknown': Maybe<[unknown]>
-[94; 124) 'Maybe:...thing)': Maybe<[unknown]>
-[106; 123) 'ref mu...ething': &mut [unknown]
-[128; 130) '()': ()
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_2.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_2.snap
deleted file mode 100644
index fd0b39b7d..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_2.snap
+++ /dev/null
@@ -1,14 +0,0 @@
---
-created: "2019-02-09T17:03:11.974225590Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[23; 53) '{     ...n']; }': ()
-[29; 50) '&[0, b...b'\n']': &[u8]
-[30; 50) '[0, b'...b'\n']': [u8]
-[31; 32) '0': u8
-[34; 39) 'b'\n'': u8
-[41; 42) '1': u8
-[44; 49) 'b'\n'': u8
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_3.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_3.snap
deleted file mode 100644
index d15b77e17..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_3.snap
+++ /dev/null
@@ -1,13 +0,0 @@
---
-created: "2019-02-09T18:02:37.377591660Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[18; 102) '{     ...   } }': ()
-[24; 100) 'match ...     }': ()
-[42; 88) 'SizeSk...tail }': [unknown]
-[76; 80) 'true': [unknown]
-[82; 86) 'tail': [unknown]
-[92; 94) '{}': ()
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_4.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_4.snap
deleted file mode 100644
index fb31883ce..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_4.snap
+++ /dev/null
@@ -1,16 +0,0 @@
---
-created: "2019-02-09T19:55:39.712470520Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[25; 110) '{     ...   } }': ()
-[31; 108) 'match ...     }': ()
-[37; 42) '*self': [unknown]
-[38; 42) 'self': [unknown]
-[53; 95) 'Borrow...), ..}': [unknown]
-[74; 77) 'box': [unknown]
-[78; 87) 'Primitive': [unknown]
-[88; 89) 'p': [unknown]
-[99; 101) '{}': ()
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_5.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_5.snap
deleted file mode 100644
index 6bbf59fb6..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_std_crash_5.snap
+++ /dev/null
@@ -1,30 +0,0 @@
---
-created: "2019-02-09T20:28:37.294693728Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[27; 323) '{     ...   } }': ()
-[33; 321) 'for co...     }': ()
-[37; 44) 'content': &[unknown]
-[48; 61) 'doesnt_matter': [unknown]
-[62; 321) '{     ...     }': ()
-[76; 80) 'name': &&[unknown]
-[83; 167) 'if doe...     }': &&[unknown]
-[86; 99) 'doesnt_matter': bool
-[100; 129) '{     ...     }': &&[unknown]
-[114; 119) 'first': &&[unknown]
-[135; 167) '{     ...     }': &&[unknown]
-[149; 157) '&content': &&[unknown]
-[150; 157) 'content': &[unknown]
-[182; 189) 'content': &&[unknown]
-[192; 314) 'if ICE...     }': &&[unknown]
-[195; 232) 'ICE_RE..._VALUE': [unknown]
-[195; 248) 'ICE_RE...&name)': bool
-[242; 247) '&name': &&&[unknown]
-[243; 247) 'name': &&[unknown]
-[249; 277) '{     ...     }': &&[unknown]
-[263; 267) 'name': &&[unknown]
-[283; 314) '{     ...     }': &[unknown]
-[297; 304) 'content': &[unknown]
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_struct.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_struct.snap
deleted file mode 100644
index 32f1fa108..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_struct.snap
+++ /dev/null
@@ -1,23 +0,0 @@
---
-created: "2019-02-20T21:31:12.910924715Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[72; 154) '{     ...a.c; }': ()
-[82; 83) 'c': C
-[86; 87) 'C': C(usize) -> C
-[86; 90) 'C(1)': C
-[88; 89) '1': usize
-[96; 97) 'B': B
-[107; 108) 'a': A
-[114; 133) 'A { b:...C(1) }': A
-[121; 122) 'B': B
-[127; 128) 'C': C(usize) -> C
-[127; 131) 'C(1)': C
-[129; 130) '1': usize
-[139; 140) 'a': A
-[139; 142) 'a.b': B
-[148; 149) 'a': A
-[148; 151) 'a.c': C
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_struct_generics.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_struct_generics.snap
deleted file mode 100644
index e07c7d36c..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_struct_generics.snap
+++ /dev/null
@@ -1,22 +0,0 @@
---
-created: "2019-01-22T14:45:00.058678600+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[36; 38) 'a1': A<u32>
-[48; 49) 'i': i32
-[56; 147) '{     ...3.x; }': ()
-[62; 64) 'a1': A<u32>
-[62; 66) 'a1.x': u32
-[76; 78) 'a2': A<i32>
-[81; 91) 'A { x: i }': A<i32>
-[88; 89) 'i': i32
-[97; 99) 'a2': A<i32>
-[97; 101) 'a2.x': i32
-[111; 113) 'a3': A<i128>
-[116; 134) 'A::<i1...x: 1 }': A<i128>
-[131; 132) '1': i128
-[140; 142) 'a3': A<i128>
-[140; 144) 'a3.x': i128
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_tuple.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_tuple.snap
deleted file mode 100644
index cd11d41d3..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_tuple.snap
+++ /dev/null
@@ -1,34 +0,0 @@
---
-created: "2019-01-22T14:45:00.058678600+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[9; 10) 'x': &str
-[18; 19) 'y': isize
-[28; 170) '{     ...d"); }': ()
-[38; 39) 'a': (u32, &str)
-[55; 63) '(1, "a")': (u32, &str)
-[56; 57) '1': u32
-[59; 62) '"a"': &str
-[73; 74) 'b': ((u32, &str), &str)
-[77; 83) '(a, x)': ((u32, &str), &str)
-[78; 79) 'a': (u32, &str)
-[81; 82) 'x': &str
-[93; 94) 'c': (isize, &str)
-[97; 103) '(y, x)': (isize, &str)
-[98; 99) 'y': isize
-[101; 102) 'x': &str
-[113; 114) 'd': ((isize, &str), &str)
-[117; 123) '(c, x)': ((isize, &str), &str)
-[118; 119) 'c': (isize, &str)
-[121; 122) 'x': &str
-[133; 134) 'e': (i32, &str)
-[137; 145) '(1, "e")': (i32, &str)
-[138; 139) '1': i32
-[141; 144) '"e"': &str
-[155; 156) 'f': ((i32, &str), &str)
-[159; 167) '(e, "d")': ((i32, &str), &str)
-[160; 161) 'e': (i32, &str)
-[163; 166) '"d"': &str
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_tuple_struct_generics.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_tuple_struct_generics.snap
deleted file mode 100644
index 783795cfd..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_tuple_struct_generics.snap
+++ /dev/null
@@ -1,23 +0,0 @@
---
-created: "2019-02-20T21:31:12.911275141Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[77; 185) '{     ...one; }': ()
-[83; 84) 'A': A<i32>(T) -> A<T>
-[83; 88) 'A(42)': A<i32>
-[85; 87) '42': i32
-[94; 95) 'A': A<u128>(T) -> A<T>
-[94; 103) 'A(42u128)': A<u128>
-[96; 102) '42u128': u128
-[109; 113) 'Some': Some<&str>(T) -> Option<T>
-[109; 118) 'Some("x")': Option<&str>
-[114; 117) '"x"': &str
-[124; 136) 'Option::Some': Some<&str>(T) -> Option<T>
-[124; 141) 'Option...e("x")': Option<&str>
-[137; 140) '"x"': &str
-[147; 151) 'None': Option<[unknown]>
-[161; 162) 'x': Option<i64>
-[178; 182) 'None': Option<i64>
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_type_alias.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_type_alias.snap
deleted file mode 100644
index 241c08353..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_type_alias.snap
+++ /dev/null
@@ -1,23 +0,0 @@
---
-created: "2019-02-24T16:13:47.561870283Z"
-creator: [email protected]
-source: crates/ra_hir/src/ty/tests.rs
-expression: "&result"
---
-[117; 118) 'x': A<u32, i128>
-[125; 126) 'y': A<&str, u128>
-[139; 140) 'z': A<u8, i8>
-[155; 212) '{     ...z.y; }': ()
-[161; 162) 'x': A<u32, i128>
-[161; 164) 'x.x': u32
-[170; 171) 'x': A<u32, i128>
-[170; 173) 'x.y': i128
-[179; 180) 'y': A<&str, u128>
-[179; 182) 'y.x': &str
-[188; 189) 'y': A<&str, u128>
-[188; 191) 'y.y': u128
-[197; 198) 'z': A<u8, i8>
-[197; 200) 'z.x': u8
-[206; 207) 'z': A<u8, i8>
-[206; 209) 'z.y': i8
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_type_param.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_type_param.snap
deleted file mode 100644
index 216d1e41f..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_type_param.snap
+++ /dev/null
@@ -1,26 +0,0 @@
---
-created: "2019-01-27T20:38:32.153717698+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[10; 11) 'x': T
-[21; 30) '{     x }': T
-[27; 28) 'x': T
-[44; 45) 'x': &T
-[56; 65) '{     x }': &T
-[62; 63) 'x': &T
-[77; 157) '{     ...(1); }': ()
-[87; 88) 'y': u32
-[91; 96) '10u32': u32
-[102; 104) 'id': fn id<u32>(T) -> T
-[102; 107) 'id(y)': u32
-[105; 106) 'y': u32
-[117; 118) 'x': bool
-[127; 132) 'clone': fn clone<bool>(&T) -> T
-[127; 135) 'clone(z)': bool
-[133; 134) 'z': &bool
-[141; 151) 'id::<i128>': fn id<i128>(T) -> T
-[141; 154) 'id::<i128>(1)': i128
-[152; 153) '1': i128
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_unary_op.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_unary_op.snap
deleted file mode 100644
index 5021d0eeb..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_unary_op.snap
+++ /dev/null
@@ -1,48 +0,0 @@
---
-created: "2019-01-28T14:51:16.185273502+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[27; 28) 'x': SomeType
-[40; 272) '{     ...lo"; }': ()
-[50; 51) 'b': bool
-[54; 59) 'false': bool
-[69; 70) 'c': bool
-[73; 75) '!b': bool
-[74; 75) 'b': bool
-[85; 86) 'a': i128
-[89; 92) '100': i128
-[102; 103) 'd': i128
-[112; 114) '-a': i128
-[113; 114) 'a': i128
-[124; 125) 'e': i32
-[128; 132) '-100': i32
-[129; 132) '100': i32
-[142; 143) 'f': bool
-[146; 153) '!!!true': bool
-[147; 153) '!!true': bool
-[148; 153) '!true': bool
-[149; 153) 'true': bool
-[163; 164) 'g': i32
-[167; 170) '!42': i32
-[168; 170) '42': i32
-[180; 181) 'h': u32
-[184; 190) '!10u32': u32
-[185; 190) '10u32': u32
-[200; 201) 'j': i128
-[204; 206) '!a': i128
-[205; 206) 'a': i128
-[212; 217) '-3.14': f64
-[213; 217) '3.14': f64
-[223; 225) '!3': i32
-[224; 225) '3': i32
-[231; 233) '-x': [unknown]
-[232; 233) 'x': SomeType
-[239; 241) '!x': [unknown]
-[240; 241) 'x': SomeType
-[247; 255) '-"hello"': [unknown]
-[248; 255) '"hello"': &str
-[261; 269) '!"hello"': [unknown]
-[262; 269) '"hello"': &str
diff --git a/crates/ra_hir/src/ty/snapshots/tests__no_panic_on_field_of_enum.snap b/crates/ra_hir/src/ty/snapshots/tests__no_panic_on_field_of_enum.snap
deleted file mode 100644
index b6f404b4c..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__no_panic_on_field_of_enum.snap
+++ /dev/null
@@ -1,11 +0,0 @@
---
-created: "2019-01-22T14:45:00.058678600+00:00"
-creator: [email protected]
-expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
---
-[20; 21) 'x': X
-[26; 47) '{     ...eld; }': ()
-[32; 33) 'x': X
-[32; 44) 'x.some_field': [unknown]
diff --git a/crates/ra_hir/src/ty/snapshots/tests__recursive_vars.snap b/crates/ra_hir/src/ty/snapshots/tests__recursive_vars.snap
deleted file mode 100644
index c3227ff7e..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__recursive_vars.snap
+++ /dev/null
@@ -1,14 +0,0 @@
---
-created: "2019-01-26T22:42:22.329980185+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[11; 48) '{     ...&y]; }': ()
-[21; 22) 'y': &[unknown]
-[25; 32) 'unknown': &[unknown]
-[38; 45) '[y, &y]': [&&[unknown]]
-[39; 40) 'y': &[unknown]
-[42; 44) '&y': &&[unknown]
-[43; 44) 'y': &[unknown]
diff --git a/crates/ra_hir/src/ty/snapshots/tests__recursive_vars_2.snap b/crates/ra_hir/src/ty/snapshots/tests__recursive_vars_2.snap
deleted file mode 100644
index de124da5b..000000000
--- a/crates/ra_hir/src/ty/snapshots/tests__recursive_vars_2.snap
+++ /dev/null
@@ -1,21 +0,0 @@
---
-created: "2019-01-26T22:42:22.331805845+00:00"
-creator: [email protected]
-expression: "&result"
-source: crates/ra_hir/src/ty/tests.rs
---
-[11; 80) '{     ...x)]; }': ()
-[21; 22) 'x': &&[unknown]
-[25; 32) 'unknown': &&[unknown]
-[42; 43) 'y': &&[unknown]
-[46; 53) 'unknown': &&[unknown]
-[59; 77) '[(x, y..., &x)]': [(&&[unknown], &&[unknown])]
-[60; 66) '(x, y)': (&&[unknown], &&[unknown])
-[61; 62) 'x': &&[unknown]
-[64; 65) 'y': &&[unknown]
-[68; 76) '(&y, &x)': (&&&[unknown], &&&[unknown])
-[69; 71) '&y': &&&[unknown]
-[70; 71) 'y': &&[unknown]
-[73; 75) '&x': &&&[unknown]
-[74; 75) 'x': &&[unknown]
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 8de46a29e..c7d409e6d 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -1,6 +1,8 @@
 use std::sync::Arc;
 use std::fmt::Write;
+use insta::assert_snapshot_matches;
 use ra_db::{SourceDatabase, salsa::Database, FilePosition};
 use ra_syntax::{algo, ast::{self, AstNode}};
 use test_utils::covers;
@@ -11,14 +13,13 @@ use crate::{
 };
 // These tests compare the inference results for all expressions in a file
-// against snapshots of the expected results using insta. Run the tests with
+// against snapshots of the expected results using insta. Use cargo-insta to
-// INSTA_UPDATE=1 to update the snapshots.
+// update the snapshots.
 #[test]
 fn infer_basics() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_basics",
+        infer(r#"
-        r#"
 fn test(a: u32, b: isize, c: !, d: &str) {
    a;
    b;
@@ -28,29 +29,49 @@ fn test(a: u32, b: isize, c: !, d: &str) {
    1isize;
    "test";
    1.0f32;
-}"#,
+}"#),
+        @r###"
+[9; 10) 'a': u32
+[17; 18) 'b': isize
+[27; 28) 'c': !
+[33; 34) 'd': &str
+[42; 121) '{     ...f32; }': ()
+[48; 49) 'a': u32
+[55; 56) 'b': isize
+[62; 63) 'c': !
+[69; 70) 'd': &str
+[76; 82) '1usize': usize
+[88; 94) '1isize': isize
+[100; 106) '"test"': &str
+[112; 118) '1.0f32': f32"###
    );
 }
 #[test]
 fn infer_let() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_let",
+        infer(r#"
-        r#"
 fn test() {
    let a = 1isize;
    let b: usize = 1;
    let c = b;
 }
-}"#,
+}"#),
+        @r###"
+[11; 71) '{     ...= b; }': ()
+[21; 22) 'a': isize
+[25; 31) '1isize': isize
+[41; 42) 'b': usize
+[52; 53) '1': usize
+[63; 64) 'c': usize
+[67; 68) 'b': usize"###
    );
 }
 #[test]
 fn infer_paths() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_paths",
+        infer(r#"
-        r#"
 fn a() -> u32 { 1 }
 mod b {
@@ -61,15 +82,24 @@ fn test() {
    a();
    b::c();
 }
-}"#,
+}"#),
+        @r###"
+[15; 20) '{ 1 }': u32
+[17; 18) '1': u32
+[48; 53) '{ 1 }': u32
+[50; 51) '1': u32
+[67; 91) '{     ...c(); }': ()
+[73; 74) 'a': fn a() -> u32
+[73; 76) 'a()': u32
+[82; 86) 'b::c': fn c() -> u32
+[82; 88) 'b::c()': u32"###
    );
 }
 #[test]
 fn infer_struct() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_struct",
+        infer(r#"
-        r#"
 struct A {
    b: B,
    c: C,
@@ -84,15 +114,31 @@ fn test() {
    a.b;
    a.c;
 }
-"#,
+"#),
+        @r###"
+[72; 154) '{     ...a.c; }': ()
+[82; 83) 'c': C
+[86; 87) 'C': C(usize) -> C
+[86; 90) 'C(1)': C
+[88; 89) '1': usize
+[96; 97) 'B': B
+[107; 108) 'a': A
+[114; 133) 'A { b:...C(1) }': A
+[121; 122) 'B': B
+[127; 128) 'C': C(usize) -> C
+[127; 131) 'C(1)': C
+[129; 130) '1': usize
+[139; 140) 'a': A
+[139; 142) 'a.b': B
+[148; 149) 'a': A
+[148; 151) 'a.c': C"###
    );
 }
 #[test]
 fn infer_enum() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_enum",
+        infer(r#"
-        r#"
 enum E {
  V1 { field: u32 },
  V2
@@ -100,15 +146,19 @@ enum E {
 fn test() {
  E::V1 { field: 1 };
  E::V2;
-}"#,
+}"#),
+        @r###"
+[48; 82) '{   E:...:V2; }': ()
+[52; 70) 'E::V1 ...d: 1 }': E
+[67; 68) '1': u32
+[74; 79) 'E::V2': E"###
    );
 }
 #[test]
 fn infer_refs() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_refs",
+        infer(r#"
-        r#"
 fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
    a;
    *a;
@@ -122,15 +172,38 @@ fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
    d;
    *d;
 }
-"#,
+"#),
+        @r###"
+[9; 10) 'a': &u32
+[18; 19) 'b': &mut u32
+[31; 32) 'c': *const u32
+[46; 47) 'd': *mut u32
+[59; 150) '{     ... *d; }': ()
+[65; 66) 'a': &u32
+[72; 74) '*a': u32
+[73; 74) 'a': &u32
+[80; 82) '&a': &&u32
+[81; 82) 'a': &u32
+[88; 94) '&mut a': &mut &u32
+[93; 94) 'a': &u32
+[100; 101) 'b': &mut u32
+[107; 109) '*b': u32
+[108; 109) 'b': &mut u32
+[115; 117) '&b': &&mut u32
+[116; 117) 'b': &mut u32
+[123; 124) 'c': *const u32
+[130; 132) '*c': u32
+[131; 132) 'c': *const u32
+[138; 139) 'd': *mut u32
+[145; 147) '*d': u32
+[146; 147) 'd': *mut u32"###
    );
 }
 #[test]
 fn infer_literals() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_literals",
+        infer(r##"
-        r##"
 fn test() {
    5i32;
    "hello";
@@ -148,15 +221,27 @@ fn test() {
        "#;
    br#"yolo"#;
 }
-"##,
+"##),
+        @r###"
+[11; 201) '{     ...o"#; }': ()
+[17; 21) '5i32': i32
+[27; 34) '"hello"': &str
+[40; 48) 'b"bytes"': &[u8]
+[54; 57) ''c'': char
+[63; 67) 'b'b'': u8
+[73; 77) '3.14': f64
+[83; 87) '5000': i32
+[93; 98) 'false': bool
+[104; 108) 'true': bool
+[114; 182) 'r#"   ...    "#': &str
+[188; 198) 'br#"yolo"#': &[u8]"###
    );
 }
 #[test]
 fn infer_unary_op() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_unary_op",
+        infer(r#"
-        r#"
 enum SomeType {}
 fn test(x: SomeType) {
@@ -176,15 +261,56 @@ fn test(x: SomeType) {
    -"hello";
    !"hello";
 }
-"#,
+"#),
+        @r###"
+[27; 28) 'x': SomeType
+[40; 272) '{     ...lo"; }': ()
+[50; 51) 'b': bool
+[54; 59) 'false': bool
+[69; 70) 'c': bool
+[73; 75) '!b': bool
+[74; 75) 'b': bool
+[85; 86) 'a': i128
+[89; 92) '100': i128
+[102; 103) 'd': i128
+[112; 114) '-a': i128
+[113; 114) 'a': i128
+[124; 125) 'e': i32
+[128; 132) '-100': i32
+[129; 132) '100': i32
+[142; 143) 'f': bool
+[146; 153) '!!!true': bool
+[147; 153) '!!true': bool
+[148; 153) '!true': bool
+[149; 153) 'true': bool
+[163; 164) 'g': i32
+[167; 170) '!42': i32
+[168; 170) '42': i32
+[180; 181) 'h': u32
+[184; 190) '!10u32': u32
+[185; 190) '10u32': u32
+[200; 201) 'j': i128
+[204; 206) '!a': i128
+[205; 206) 'a': i128
+[212; 217) '-3.14': f64
+[213; 217) '3.14': f64
+[223; 225) '!3': i32
+[224; 225) '3': i32
+[231; 233) '-x': {unknown}
+[232; 233) 'x': SomeType
+[239; 241) '!x': {unknown}
+[240; 241) 'x': SomeType
+[247; 255) '-"hello"': {unknown}
+[248; 255) '"hello"': &str
+[261; 269) '!"hello"': {unknown}
+[262; 269) '"hello"': &str"###
    );
 }
 #[test]
 fn infer_backwards() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_backwards",
+        infer(r#"
-        r#"
 fn takes_u32(x: u32) {}
 struct S { i32_field: i32 }
@@ -197,15 +323,35 @@ fn test() -> &mut &f64 {
    let c = unknown_function();
    &mut &c
 }
-"#,
+"#),
+        @r###"
+[14; 15) 'x': u32
+[22; 24) '{}': ()
+[78; 231) '{     ...t &c }': &mut &f64
+[88; 89) 'a': u32
+[92; 108) 'unknow...nction': {unknown}
+[92; 110) 'unknow...tion()': u32
+[116; 125) 'takes_u32': fn takes_u32(u32) -> ()
+[116; 128) 'takes_u32(a)': ()
+[126; 127) 'a': u32
+[138; 139) 'b': i32
+[142; 158) 'unknow...nction': {unknown}
+[142; 160) 'unknow...tion()': i32
+[166; 184) 'S { i3...d: b }': S
+[181; 182) 'b': i32
+[194; 195) 'c': f64
+[198; 214) 'unknow...nction': {unknown}
+[198; 216) 'unknow...tion()': f64
+[222; 229) '&mut &c': &mut &f64
+[227; 229) '&c': &f64
+[228; 229) 'c': f64"###
    );
 }
 #[test]
 fn infer_self() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_self",
+        infer(r#"
-        r#"
 struct S;
 impl S {
@@ -222,15 +368,25 @@ impl S {
        Self {}
    }
 }
-"#,
+"#),
+        @r###"
+[34; 38) 'self': &S
+[40; 61) '{     ...     }': ()
+[50; 54) 'self': &S
+[75; 79) 'self': &S
+[88; 109) '{     ...     }': ()
+[98; 102) 'self': &S
+[133; 153) '{     ...     }': S
+[143; 147) 'S {}': S
+[177; 200) '{     ...     }': S
+[187; 194) 'Self {}': S"###
    );
 }
 #[test]
 fn infer_binary_op() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_binary_op",
+        infer(r#"
-        r#"
 fn f(x: bool) -> i32 {
    0i32
 }
@@ -250,15 +406,65 @@ fn test() -> bool {
    ten < 3
 }
-"#,
+"#),
+        @r###"
+[6; 7) 'x': bool
+[22; 34) '{     0i32 }': i32
+[28; 32) '0i32': i32
+[54; 370) '{     ... < 3 }': bool
+[64; 65) 'x': bool
+[68; 69) 'a': bool
+[68; 74) 'a && b': bool
+[73; 74) 'b': bool
+[84; 85) 'y': bool
+[88; 92) 'true': bool
+[88; 101) 'true || false': bool
+[96; 101) 'false': bool
+[111; 112) 'z': bool
+[115; 116) 'x': bool
+[115; 121) 'x == y': bool
+[120; 121) 'y': bool
+[131; 132) 't': bool
+[135; 136) 'x': bool
+[135; 141) 'x != y': bool
+[140; 141) 'y': bool
+[151; 162) 'minus_forty': isize
+[172; 180) '-40isize': isize
+[173; 180) '40isize': isize
+[190; 191) 'h': bool
+[194; 205) 'minus_forty': isize
+[194; 216) 'minus_...ONST_2': bool
+[209; 216) 'CONST_2': isize
+[226; 227) 'c': i32
+[230; 231) 'f': fn f(bool) -> i32
+[230; 239) 'f(z || y)': i32
+[230; 243) 'f(z || y) + 5': i32
+[232; 233) 'z': bool
+[232; 238) 'z || y': bool
+[237; 238) 'y': bool
+[242; 243) '5': i32
+[253; 254) 'd': {unknown}
+[257; 258) 'b': {unknown}
+[268; 269) 'g': ()
+[272; 283) 'minus_forty': isize
+[272; 288) 'minus_...y ^= i': ()
+[287; 288) 'i': isize
+[298; 301) 'ten': usize
+[311; 313) '10': usize
+[323; 336) 'ten_is_eleven': bool
+[339; 342) 'ten': usize
+[339; 354) 'ten == some_num': bool
+[346; 354) 'some_num': usize
+[361; 364) 'ten': usize
+[361; 368) 'ten < 3': bool
+[367; 368) '3': usize"###
    );
 }
 #[test]
 fn infer_field_autoderef() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_field_autoderef",
+        infer(r#"
-        r#"
 struct A {
    b: B,
 }
@@ -281,27 +487,75 @@ fn test2(a1: *const A, a2: *mut A) {
    a1.b;
    a2.b;
 }
-"#,
+"#),
+        @r###"
+[44; 45) 'a': A
+[50; 213) '{     ...5.b; }': ()
+[60; 62) 'a1': A
+[65; 66) 'a': A
+[72; 74) 'a1': A
+[72; 76) 'a1.b': B
+[86; 88) 'a2': &A
+[91; 93) '&a': &A
+[92; 93) 'a': A
+[99; 101) 'a2': &A
+[99; 103) 'a2.b': B
+[113; 115) 'a3': &mut A
+[118; 124) '&mut a': &mut A
+[123; 124) 'a': A
+[130; 132) 'a3': &mut A
+[130; 134) 'a3.b': B
+[144; 146) 'a4': &&&&&&&A
+[149; 157) '&&&&&&&a': &&&&&&&A
+[150; 157) '&&&&&&a': &&&&&&A
+[151; 157) '&&&&&a': &&&&&A
+[152; 157) '&&&&a': &&&&A
+[153; 157) '&&&a': &&&A
+[154; 157) '&&a': &&A
+[155; 157) '&a': &A
+[156; 157) 'a': A
+[163; 165) 'a4': &&&&&&&A
+[163; 167) 'a4.b': B
+[177; 179) 'a5': &mut &&mut &&mut A
+[182; 200) '&mut &...&mut a': &mut &&mut &&mut A
+[187; 200) '&&mut &&mut a': &&mut &&mut A
+[188; 200) '&mut &&mut a': &mut &&mut A
+[193; 200) '&&mut a': &&mut A
+[194; 200) '&mut a': &mut A
+[199; 200) 'a': A
+[206; 208) 'a5': &mut &&mut &&mut A
+[206; 210) 'a5.b': B
+[224; 226) 'a1': *const A
+[238; 240) 'a2': *mut A
+[250; 273) '{     ...2.b; }': ()
+[256; 258) 'a1': *const A
+[256; 260) 'a1.b': B
+[266; 268) 'a2': *mut A
+[266; 270) 'a2.b': B"###
    );
 }
 #[test]
 fn bug_484() {
-    check_inference(
+    assert_snapshot_matches!(
-        "bug_484",
+        infer(r#"
-        r#"
 fn test() {
   let x = if true {};
 }
-"#,
+"#),
+        @r###"
+[11; 37) '{    l... {}; }': ()
+[20; 21) 'x': ()
+[24; 34) 'if true {}': ()
+[27; 31) 'true': bool
+[32; 34) '{}': ()"###
    );
 }
 #[test]
 fn infer_in_elseif() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_in_elseif",
+        infer(r#"
-        r#"
 struct Foo { field: i32 }
 fn main(foo: Foo) {
    if true {
@@ -310,15 +564,25 @@ fn main(foo: Foo) {
        foo.field
    }
 }
-"#,
+"#),
+        @r###"
+[35; 38) 'foo': Foo
+[45; 109) '{     ...   } }': ()
+[51; 107) 'if tru...     }': ()
+[54; 58) 'true': bool
+[59; 67) '{      }': ()
+[73; 107) 'if fal...     }': i32
+[76; 81) 'false': bool
+[82; 107) '{     ...     }': i32
+[92; 95) 'foo': Foo
+[92; 101) 'foo.field': i32"###
    )
 }
 #[test]
 fn infer_inherent_method() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_inherent_method",
+        infer(r#"
-        r#"
 struct A;
 impl A {
@@ -336,15 +600,33 @@ fn test(a: A) {
    (&a).bar(1);
    a.bar(1);
 }
-"#,
+"#),
+        @r###"
+[32; 36) 'self': A
+[38; 39) 'x': u32
+[53; 55) '{}': ()
+[103; 107) 'self': &A
+[109; 110) 'x': u64
+[124; 126) '{}': ()
+[144; 145) 'a': A
+[150; 198) '{     ...(1); }': ()
+[156; 157) 'a': A
+[156; 164) 'a.foo(1)': i32
+[162; 163) '1': u32
+[170; 181) '(&a).bar(1)': i64
+[171; 173) '&a': &A
+[172; 173) 'a': A
+[179; 180) '1': u64
+[187; 188) 'a': A
+[187; 195) 'a.bar(1)': i64
+[193; 194) '1': u64"###
    );
 }
 #[test]
 fn infer_tuple() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_tuple",
+        infer(r#"
-        r#"
 fn test(x: &str, y: isize) {
    let a: (u32, &str) = (1, "a");
    let b = (a, x);
@@ -353,15 +635,42 @@ fn test(x: &str, y: isize) {
    let e = (1, "e");
    let f = (e, "d");
 }
-"#,
+"#),
+        @r###"
+[9; 10) 'x': &str
+[18; 19) 'y': isize
+[28; 170) '{     ...d"); }': ()
+[38; 39) 'a': (u32, &str)
+[55; 63) '(1, "a")': (u32, &str)
+[56; 57) '1': u32
+[59; 62) '"a"': &str
+[73; 74) 'b': ((u32, &str), &str)
+[77; 83) '(a, x)': ((u32, &str), &str)
+[78; 79) 'a': (u32, &str)
+[81; 82) 'x': &str
+[93; 94) 'c': (isize, &str)
+[97; 103) '(y, x)': (isize, &str)
+[98; 99) 'y': isize
+[101; 102) 'x': &str
+[113; 114) 'd': ((isize, &str), &str)
+[117; 123) '(c, x)': ((isize, &str), &str)
+[118; 119) 'c': (isize, &str)
+[121; 122) 'x': &str
+[133; 134) 'e': (i32, &str)
+[137; 145) '(1, "e")': (i32, &str)
+[138; 139) '1': i32
+[141; 144) '"e"': &str
+[155; 156) 'f': ((i32, &str), &str)
+[159; 167) '(e, "d")': ((i32, &str), &str)
+[160; 161) 'e': (i32, &str)
+[163; 166) '"d"': &str"###
    );
 }
 #[test]
 fn infer_array() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_array",
+        infer(r#"
-        r#"
 fn test(x: &str, y: isize) {
    let a = [x];
    let b = [a, a];
@@ -380,15 +689,73 @@ fn test(x: &str, y: isize) {
    let x: [u8; 0] = [];
    let z: &[u8] = &[1, 2, 3];
 }
-"#,
+"#),
+        @r###"
+[9; 10) 'x': &str
+[18; 19) 'y': isize
+[28; 324) '{     ... 3]; }': ()
+[38; 39) 'a': [&str]
+[42; 45) '[x]': [&str]
+[43; 44) 'x': &str
+[55; 56) 'b': [[&str]]
+[59; 65) '[a, a]': [[&str]]
+[60; 61) 'a': [&str]
+[63; 64) 'a': [&str]
+[75; 76) 'c': [[[&str]]]
+[79; 85) '[b, b]': [[[&str]]]
+[80; 81) 'b': [[&str]]
+[83; 84) 'b': [[&str]]
+[96; 97) 'd': [isize]
+[100; 112) '[y, 1, 2, 3]': [isize]
+[101; 102) 'y': isize
+[104; 105) '1': isize
+[107; 108) '2': isize
+[110; 111) '3': isize
+[122; 123) 'd': [isize]
+[126; 138) '[1, y, 2, 3]': [isize]
+[127; 128) '1': isize
+[130; 131) 'y': isize
+[133; 134) '2': isize
+[136; 137) '3': isize
+[148; 149) 'e': [isize]
+[152; 155) '[y]': [isize]
+[153; 154) 'y': isize
+[165; 166) 'f': [[isize]]
+[169; 175) '[d, d]': [[isize]]
+[170; 171) 'd': [isize]
+[173; 174) 'd': [isize]
+[185; 186) 'g': [[isize]]
+[189; 195) '[e, e]': [[isize]]
+[190; 191) 'e': [isize]
+[193; 194) 'e': [isize]
+[206; 207) 'h': [i32]
+[210; 216) '[1, 2]': [i32]
+[211; 212) '1': i32
+[214; 215) '2': i32
+[226; 227) 'i': [&str]
+[230; 240) '["a", "b"]': [&str]
+[231; 234) '"a"': &str
+[236; 239) '"b"': &str
+[251; 252) 'b': [[&str]]
+[255; 265) '[a, ["b"]]': [[&str]]
+[256; 257) 'a': [&str]
+[259; 264) '["b"]': [&str]
+[260; 263) '"b"': &str
+[275; 276) 'x': [u8]
+[288; 290) '[]': [u8]
+[300; 301) 'z': &[u8]
+[311; 321) '&[1, 2, 3]': &[u8]
+[312; 321) '[1, 2, 3]': [u8]
+[313; 314) '1': u8
+[316; 317) '2': u8
+[319; 320) '3': u8"###
    );
 }
 #[test]
 fn infer_pattern() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_pattern",
+        infer(r#"
-        r#"
 fn test(x: &i32) {
    let y = x;
    let &z = x;
@@ -410,15 +777,62 @@ fn test(x: &i32) {
    let ref mut mut_ref_to_x = x;
    let k = mut_ref_to_x;
 }
-"#,
+"#),
+        @r###"
+[9; 10) 'x': &i32
+[18; 369) '{     ...o_x; }': ()
+[28; 29) 'y': &i32
+[32; 33) 'x': &i32
+[43; 45) '&z': &i32
+[44; 45) 'z': i32
+[48; 49) 'x': &i32
+[59; 60) 'a': i32
+[63; 64) 'z': i32
+[74; 80) '(c, d)': (i32, &str)
+[75; 76) 'c': i32
+[78; 79) 'd': &str
+[83; 95) '(1, "hello")': (i32, &str)
+[84; 85) '1': i32
+[87; 94) '"hello"': &str
+[102; 152) 'for (e...     }': ()
+[106; 112) '(e, f)': ({unknown}, {unknown})
+[107; 108) 'e': {unknown}
+[110; 111) 'f': {unknown}
+[116; 125) 'some_iter': {unknown}
+[126; 152) '{     ...     }': ()
+[140; 141) 'g': {unknown}
+[144; 145) 'e': {unknown}
+[158; 205) 'if let...     }': ()
+[165; 170) '[val]': {unknown}
+[173; 176) 'opt': {unknown}
+[177; 205) '{     ...     }': ()
+[191; 192) 'h': {unknown}
+[195; 198) 'val': {unknown}
+[215; 221) 'lambda': {unknown}
+[224; 256) '|a: u6...b; c }': {unknown}
+[225; 226) 'a': u64
+[233; 234) 'b': u64
+[236; 237) 'c': i32
+[244; 256) '{ a + b; c }': i32
+[246; 247) 'a': u64
+[246; 251) 'a + b': u64
+[250; 251) 'b': u64
+[253; 254) 'c': i32
+[267; 279) 'ref ref_to_x': &&i32
+[282; 283) 'x': &i32
+[293; 302) 'mut mut_x': &i32
+[305; 306) 'x': &i32
+[316; 336) 'ref mu...f_to_x': &mut &i32
+[339; 340) 'x': &i32
+[350; 351) 'k': &mut &i32
+[354; 366) 'mut_ref_to_x': &mut &i32"###
    );
 }
 #[test]
 fn infer_adt_pattern() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_adt_pattern",
+        infer(r#"
-        r#"
 enum E {
    A { x: usize },
    B
@@ -441,15 +855,40 @@ fn test() {
    let ref d @ E::A { .. } = e;
    d;
 }
-"#,
+"#),
+        @r###"
+[68; 289) '{     ...  d; }': ()
+[78; 79) 'e': E
+[82; 95) 'E::A { x: 3 }': E
+[92; 93) '3': usize
+[106; 113) 'S(y, z)': S
+[108; 109) 'y': u32
+[111; 112) 'z': E
+[116; 119) 'foo': S
+[129; 148) 'E::A {..._var }': E
+[139; 146) 'new_var': usize
+[151; 152) 'e': E
+[159; 245) 'match ...     }': usize
+[165; 166) 'e': E
+[177; 187) 'E::A { x }': E
+[184; 185) 'x': usize
+[191; 192) 'x': usize
+[202; 206) 'E::B': E
+[210; 213) 'foo': bool
+[217; 218) '1': usize
+[228; 232) 'E::B': E
+[236; 238) '10': usize
+[256; 275) 'ref d ...{ .. }': &E
+[264; 275) 'E::A { .. }': E
+[278; 279) 'e': E
+[285; 286) 'd': &E"###
    );
 }
 #[test]
 fn infer_struct_generics() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_struct_generics",
+        infer(r#"
-        r#"
 struct A<T> {
    x: T,
 }
@@ -461,15 +900,30 @@ fn test(a1: A<u32>, i: i32) {
    let a3 = A::<i128> { x: 1 };
    a3.x;
 }
-"#,
+"#),
+        @r###"
+[36; 38) 'a1': A<u32>
+[48; 49) 'i': i32
+[56; 147) '{     ...3.x; }': ()
+[62; 64) 'a1': A<u32>
+[62; 66) 'a1.x': u32
+[76; 78) 'a2': A<i32>
+[81; 91) 'A { x: i }': A<i32>
+[88; 89) 'i': i32
+[97; 99) 'a2': A<i32>
+[97; 101) 'a2.x': i32
+[111; 113) 'a3': A<i128>
+[116; 134) 'A::<i1...x: 1 }': A<i128>
+[131; 132) '1': i128
+[140; 142) 'a3': A<i128>
+[140; 144) 'a3.x': i128"###
    );
 }
 #[test]
 fn infer_tuple_struct_generics() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_tuple_struct_generics",
+        infer(r#"
-        r#"
 struct A<T>(T);
 enum Option<T> { Some(T), None };
 use Option::*;
@@ -482,15 +936,31 @@ fn test() {
    None;
    let x: Option<i64> = None;
 }
-"#,
+"#),
+        @r###"
+[77; 185) '{     ...one; }': ()
+[83; 84) 'A': A<i32>(T) -> A<T>
+[83; 88) 'A(42)': A<i32>
+[85; 87) '42': i32
+[94; 95) 'A': A<u128>(T) -> A<T>
+[94; 103) 'A(42u128)': A<u128>
+[96; 102) '42u128': u128
+[109; 113) 'Some': Some<&str>(T) -> Option<T>
+[109; 118) 'Some("x")': Option<&str>
+[114; 117) '"x"': &str
+[124; 136) 'Option::Some': Some<&str>(T) -> Option<T>
+[124; 141) 'Option...e("x")': Option<&str>
+[137; 140) '"x"': &str
+[147; 151) 'None': Option<{unknown}>
+[161; 162) 'x': Option<i64>
+[178; 182) 'None': Option<i64>"###
    );
 }
 #[test]
 fn infer_generics_in_patterns() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_generics_in_patterns",
+        infer(r#"
-        r#"
 struct A<T> {
    x: T,
 }
@@ -508,15 +978,32 @@ fn test(a1: A<u32>, o: Option<u64>) {
        _ => 1,
    };
 }
-"#,
+"#),
+        @r###"
+[79; 81) 'a1': A<u32>
+[91; 92) 'o': Option<u64>
+[107; 244) '{     ...  }; }': ()
+[117; 128) 'A { x: x2 }': A<u32>
+[124; 126) 'x2': u32
+[131; 133) 'a1': A<u32>
+[143; 161) 'A::<i6...: x3 }': A<i64>
+[157; 159) 'x3': i64
+[164; 174) 'A { x: 1 }': A<i64>
+[171; 172) '1': i64
+[180; 241) 'match ...     }': u64
+[186; 187) 'o': Option<u64>
+[198; 213) 'Option::Some(t)': Option<u64>
+[211; 212) 't': u64
+[217; 218) 't': u64
+[228; 229) '_': Option<u64>
+[233; 234) '1': u64"###
    );
 }
 #[test]
 fn infer_function_generics() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_function_generics",
+        infer(r#"
-        r#"
 fn id<T>(t: T) -> T { t }
 fn test() {
@@ -524,15 +1011,29 @@ fn test() {
    id::<i128>(1);
    let x: u64 = id(1);
 }
-"#,
+"#),
+        @r###"
+[10; 11) 't': T
+[21; 26) '{ t }': T
+[23; 24) 't': T
+[38; 98) '{     ...(1); }': ()
+[44; 46) 'id': fn id<u32>(T) -> T
+[44; 52) 'id(1u32)': u32
+[47; 51) '1u32': u32
+[58; 68) 'id::<i128>': fn id<i128>(T) -> T
+[58; 71) 'id::<i128>(1)': i128
+[69; 70) '1': i128
+[81; 82) 'x': u64
+[90; 92) 'id': fn id<u64>(T) -> T
+[90; 95) 'id(1)': u64
+[93; 94) '1': u64"###
    );
 }
 #[test]
 fn infer_impl_generics() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_impl_generics",
+        infer(r#"
-        r#"
 struct A<T1, T2> {
    x: T1,
    y: T2,
@@ -556,15 +1057,47 @@ fn test() -> i128 {
    a.z(1i128);
    a.z::<u128>(1);
 }
-"#,
+"#),
+        @r###"
+[74; 78) 'self': A<X, Y>
+[85; 107) '{     ...     }': X
+[95; 99) 'self': A<X, Y>
+[95; 101) 'self.x': X
+[117; 121) 'self': A<X, Y>
+[128; 150) '{     ...     }': Y
+[138; 142) 'self': A<X, Y>
+[138; 144) 'self.y': Y
+[163; 167) 'self': A<X, Y>
+[169; 170) 't': T
+[188; 223) '{     ...     }': (X, Y, T)
+[198; 217) '(self.....y, t)': (X, Y, T)
+[199; 203) 'self': A<X, Y>
+[199; 205) 'self.x': X
+[207; 211) 'self': A<X, Y>
+[207; 213) 'self.y': Y
+[215; 216) 't': T
+[245; 342) '{     ...(1); }': ()
+[255; 256) 'a': A<u64, i64>
+[259; 281) 'A { x:...1i64 }': A<u64, i64>
+[266; 270) '1u64': u64
+[275; 279) '1i64': i64
+[287; 288) 'a': A<u64, i64>
+[287; 292) 'a.x()': u64
+[298; 299) 'a': A<u64, i64>
+[298; 303) 'a.y()': i64
+[309; 310) 'a': A<u64, i64>
+[309; 319) 'a.z(1i128)': (u64, i64, i128)
+[313; 318) '1i128': i128
+[325; 326) 'a': A<u64, i64>
+[325; 339) 'a.z::<u128>(1)': (u64, i64, u128)
+[337; 338) '1': u128"###
    );
 }
 #[test]
 fn infer_impl_generics_with_autoderef() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_impl_generics_with_autoderef",
+        infer(r#"
-        r#"
 enum Option<T> {
    Some(T),
    None,
@@ -576,15 +1109,24 @@ fn test(o: Option<u32>) {
    (&o).as_ref();
    o.as_ref();
 }
-"#,
+"#),
+        @r###"
+[78; 82) 'self': &Option<T>
+[98; 100) '{}': ()
+[111; 112) 'o': Option<u32>
+[127; 165) '{     ...f(); }': ()
+[133; 146) '(&o).as_ref()': Option<&u32>
+[134; 136) '&o': &Option<u32>
+[135; 136) 'o': Option<u32>
+[152; 153) 'o': Option<u32>
+[152; 162) 'o.as_ref()': Option<&u32>"###
    );
 }
 #[test]
 fn infer_generic_chain() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_generic_chain",
+        infer(r#"
-        r#"
 struct A<T> {
    x: T,
 }
@@ -603,15 +1145,44 @@ fn test() -> i128 {
     let b = A { x: z };
     b.x()
 }
-"#,
+"#),
+        @r###"
+[53; 57) 'self': A<T2>
+[65; 87) '{     ...     }': T2
+[75; 79) 'self': A<T2>
+[75; 81) 'self.x': T2
+[99; 100) 't': T
+[110; 115) '{ t }': T
+[112; 113) 't': T
+[135; 261) '{     ....x() }': i128
+[146; 147) 'x': i128
+[150; 151) '1': i128
+[162; 163) 'y': i128
+[166; 168) 'id': fn id<i128>(T) -> T
+[166; 171) 'id(x)': i128
+[169; 170) 'x': i128
+[182; 183) 'a': A<i128>
+[186; 200) 'A { x: id(y) }': A<i128>
+[193; 195) 'id': fn id<i128>(T) -> T
+[193; 198) 'id(y)': i128
+[196; 197) 'y': i128
+[211; 212) 'z': i128
+[215; 217) 'id': fn id<i128>(T) -> T
+[215; 222) 'id(a.x)': i128
+[218; 219) 'a': A<i128>
+[218; 221) 'a.x': i128
+[233; 234) 'b': A<i128>
+[237; 247) 'A { x: z }': A<i128>
+[244; 245) 'z': i128
+[254; 255) 'b': A<i128>
+[254; 259) 'b.x()': i128"###
    );
 }
 #[test]
 fn infer_associated_const() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_associated_const",
+        infer(r#"
-        r#"
 struct Struct;
 impl Struct {
@@ -639,15 +1210,22 @@ fn test() {
    let y = Enum::BAR;
    let z = TraitTest::ID;
 }
-"#,
+"#),
+        @r###"
+[227; 305) '{     ...:ID; }': ()
+[237; 238) 'x': u32
+[241; 252) 'Struct::FOO': u32
+[262; 263) 'y': u32
+[266; 275) 'Enum::BAR': u32
+[285; 286) 'z': u32
+[289; 302) 'TraitTest::ID': u32"###
    );
 }
 #[test]
 fn infer_associated_method_struct() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_associated_method_struct",
+        infer(r#"
-        r#"
 struct A { x: u32 };
 impl A {
@@ -659,15 +1237,24 @@ fn test() {
    let a = A::new();
    a.x;
 }
-"#,
+"#),
+        @r###"
+[50; 76) '{     ...     }': A
+[60; 70) 'A { x: 0 }': A
+[67; 68) '0': u32
+[89; 123) '{     ...a.x; }': ()
+[99; 100) 'a': A
+[103; 109) 'A::new': fn new() -> A
+[103; 111) 'A::new()': A
+[117; 118) 'a': A
+[117; 120) 'a.x': u32"###
    );
 }
 #[test]
 fn infer_associated_method_enum() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_associated_method_enum",
+        infer(r#"
-        r#"
 enum A { B, C };
 impl A {
@@ -684,15 +1271,28 @@ fn test() {
    let c = A::c();
    c;
 }
-"#,
+"#),
+        @r###"
+[48; 68) '{     ...     }': A
+[58; 62) 'A::B': A
+[89; 109) '{     ...     }': A
+[99; 103) 'A::C': A
+[122; 179) '{     ...  c; }': ()
+[132; 133) 'a': A
+[136; 140) 'A::b': fn b() -> A
+[136; 142) 'A::b()': A
+[148; 149) 'a': A
+[159; 160) 'c': A
+[163; 167) 'A::c': fn c() -> A
+[163; 169) 'A::c()': A
+[175; 176) 'c': A"###
    );
 }
 #[test]
 fn infer_associated_method_with_modules() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_associated_method_with_modules",
+        infer(r#"
-        r#"
 mod a {
    struct A;
    impl A { pub fn thing() -> A { A {} }}
@@ -714,15 +1314,31 @@ fn test() {
    let y = b::B::thing();
    let z = c::C::thing();
 }
-"#,
+"#),
+        @r###"
+[56; 64) '{ A {} }': A
+[58; 62) 'A {}': A
+[126; 132) '{ 99 }': u32
+[128; 130) '99': u32
+[202; 210) '{ C {} }': C
+[204; 208) 'C {}': C
+[241; 325) '{     ...g(); }': ()
+[251; 252) 'x': A
+[255; 266) 'a::A::thing': fn thing() -> A
+[255; 268) 'a::A::thing()': A
+[278; 279) 'y': u32
+[282; 293) 'b::B::thing': fn thing() -> u32
+[282; 295) 'b::B::thing()': u32
+[305; 306) 'z': C
+[309; 320) 'c::C::thing': fn thing() -> C
+[309; 322) 'c::C::thing()': C"###
    );
 }
 #[test]
 fn infer_associated_method_generics() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_associated_method_generics",
+        infer(r#"
-        r#"
 struct Gen<T> {
    val: T
 }
@@ -736,15 +1352,24 @@ impl<T> Gen<T> {
 fn test() {
    let a = Gen::make(0u32);
 }
-"#,
+"#),
+        @r###"
+[64; 67) 'val': T
+[82; 109) '{     ...     }': Gen<T>
+[92; 103) 'Gen { val }': Gen<T>
+[98; 101) 'val': T
+[123; 155) '{     ...32); }': ()
+[133; 134) 'a': Gen<u32>
+[137; 146) 'Gen::make': fn make<u32>(T) -> Gen<T>
+[137; 152) 'Gen::make(0u32)': Gen<u32>
+[147; 151) '0u32': u32"###
    );
 }
 #[test]
 fn infer_type_alias() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_type_alias",
+        infer(r#"
-        r#"
 struct A<X, Y> { x: X, y: Y };
 type Foo = A<u32, i128>;
 type Bar<T> = A<T, u128>;
@@ -757,43 +1382,63 @@ fn test(x: Foo, y: Bar<&str>, z: Baz<i8, u8>) {
    z.x;
    z.y;
 }
-"#,
+"#),
+        @r###"
+[117; 118) 'x': A<u32, i128>
+[125; 126) 'y': A<&str, u128>
+[139; 140) 'z': A<u8, i8>
+[155; 212) '{     ...z.y; }': ()
+[161; 162) 'x': A<u32, i128>
+[161; 164) 'x.x': u32
+[170; 171) 'x': A<u32, i128>
+[170; 173) 'x.y': i128
+[179; 180) 'y': A<&str, u128>
+[179; 182) 'y.x': &str
+[188; 189) 'y': A<&str, u128>
+[188; 191) 'y.y': u128
+[197; 198) 'z': A<u8, i8>
+[197; 200) 'z.x': u8
+[206; 207) 'z': A<u8, i8>
+[206; 209) 'z.y': i8"###
    )
 }
 #[test]
 #[should_panic] // we currently can't handle this
 fn recursive_type_alias() {
-    check_inference(
+    assert_snapshot_matches!(
-        "recursive_type_alias",
+        infer(r#"
-        r#"
 struct A<X> {};
 type Foo = Foo;
 type Bar = A<Bar>;
 fn test(x: Foo) {}
-"#,
+"#),
+        @""
    )
 }
 #[test]
 fn no_panic_on_field_of_enum() {
-    check_inference(
+    assert_snapshot_matches!(
-        "no_panic_on_field_of_enum",
+        infer(r#"
-        r#"
 enum X {}
 fn test(x: X) {
    x.some_field;
 }
-"#,
+"#),
+        @r###"
+[20; 21) 'x': X
+[26; 47) '{     ...eld; }': ()
+[32; 33) 'x': X
+[32; 44) 'x.some_field': {unknown}"###
    );
 }
 #[test]
 fn bug_585() {
-    check_inference(
+    assert_snapshot_matches!(
-        "bug_585",
+        infer(r#"
-        r#"
 fn test() {
    X {};
    match x {
@@ -801,20 +1446,35 @@ fn test() {
        A::Y() => (),
    }
 }
-"#,
+"#),
+        @r###"
+[11; 89) '{     ...   } }': ()
+[17; 21) 'X {}': {unknown}
+[27; 87) 'match ...     }': ()
+[33; 34) 'x': {unknown}
+[45; 52) 'A::B {}': {unknown}
+[56; 58) '()': ()
+[68; 74) 'A::Y()': {unknown}
+[78; 80) '()': ()"###
    );
 }
 #[test]
 fn bug_651() {
-    check_inference(
+    assert_snapshot_matches!(
-        "bug_651",
+        infer(r#"
-        r#"
 fn quux() {
    let y = 92;
    1 + y;
 }
-"#,
+"#),
+        @r###"
+[11; 41) '{     ...+ y; }': ()
+[21; 22) 'y': i32
+[25; 27) '92': i32
+[33; 34) '1': i32
+[33; 38) '1 + y': i32
+[37; 38) 'y': i32"###
    );
 }
@@ -822,14 +1482,21 @@ fn quux() {
 fn recursive_vars() {
    covers!(type_var_cycles_resolve_completely);
    covers!(type_var_cycles_resolve_as_possible);
-    check_inference(
+    assert_snapshot_matches!(
-        "recursive_vars",
+        infer(r#"
-        r#"
 fn test() {
    let y = unknown;
    [y, &y];
 }
-"#,
+"#),
+        @r###"
+[11; 48) '{     ...&y]; }': ()
+[21; 22) 'y': &{unknown}
+[25; 32) 'unknown': &{unknown}
+[38; 45) '[y, &y]': [&&{unknown}]
+[39; 40) 'y': &{unknown}
+[42; 44) '&y': &&{unknown}
+[43; 44) 'y': &{unknown}"###
    );
 }
@@ -837,23 +1504,36 @@ fn test() {
 fn recursive_vars_2() {
    covers!(type_var_cycles_resolve_completely);
    covers!(type_var_cycles_resolve_as_possible);
-    check_inference(
+    assert_snapshot_matches!(
-        "recursive_vars_2",
+        infer(r#"
-        r#"
 fn test() {
    let x = unknown;
    let y = unknown;
    [(x, y), (&y, &x)];
 }
-"#,
+"#),
+        @r###"
+[11; 80) '{     ...x)]; }': ()
+[21; 22) 'x': &&{unknown}
+[25; 32) 'unknown': &&{unknown}
+[42; 43) 'y': &&{unknown}
+[46; 53) 'unknown': &&{unknown}
+[59; 77) '[(x, y..., &x)]': [(&&{unknown}, &&{unknown})]
+[60; 66) '(x, y)': (&&{unknown}, &&{unknown})
+[61; 62) 'x': &&{unknown}
+[64; 65) 'y': &&{unknown}
+[68; 76) '(&y, &x)': (&&&{unknown}, &&&{unknown})
+[69; 71) '&y': &&&{unknown}
+[70; 71) 'y': &&{unknown}
+[73; 75) '&x': &&&{unknown}
+[74; 75) 'x': &&{unknown}"###
    );
 }
 #[test]
 fn infer_type_param() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_type_param",
+        infer(r#"
-        r#"
 fn id<T>(x: T) -> T {
    x
 }
@@ -868,16 +1548,35 @@ fn test() {
    let x: bool = clone(z);
    id::<i128>(1);
 }
-"#,
+"#),
+        @r###"
+[10; 11) 'x': T
+[21; 30) '{     x }': T
+[27; 28) 'x': T
+[44; 45) 'x': &T
+[56; 65) '{     x }': &T
+[62; 63) 'x': &T
+[77; 157) '{     ...(1); }': ()
+[87; 88) 'y': u32
+[91; 96) '10u32': u32
+[102; 104) 'id': fn id<u32>(T) -> T
+[102; 107) 'id(y)': u32
+[105; 106) 'y': u32
+[117; 118) 'x': bool
+[127; 132) 'clone': fn clone<bool>(&T) -> T
+[127; 135) 'clone(z)': bool
+[133; 134) 'z': &bool
+[141; 151) 'id::<i128>': fn id<i128>(T) -> T
+[141; 154) 'id::<i128>(1)': i128
+[152; 153) '1': i128"###
    );
 }
 #[test]
 fn infer_std_crash_1() {
    // caused stack overflow, taken from std
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_std_crash_1",
+        infer(r#"
-        r#"
 enum Maybe<T> {
    Real(T),
    Fake,
@@ -888,7 +1587,14 @@ fn write() {
        Maybe::Real(ref mut something) => (),
    }
 }
-"#,
+"#),
+        @r###"
+[54; 139) '{     ...   } }': ()
+[60; 137) 'match ...     }': ()
+[66; 83) 'someth...nknown': Maybe<{unknown}>
+[94; 124) 'Maybe:...thing)': Maybe<{unknown}>
+[106; 123) 'ref mu...ething': &mut {unknown}
+[128; 130) '()': ()"###
    );
 }
@@ -896,52 +1602,73 @@ fn write() {
 fn infer_std_crash_2() {
    covers!(type_var_resolves_to_int_var);
    // caused "equating two type variables, ...", taken from std
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_std_crash_2",
+        infer(r#"
-        r#"
 fn test_line_buffer() {
    &[0, b'\n', 1, b'\n'];
 }
-"#,
+"#),
+        @r###"
+[23; 53) '{     ...n']; }': ()
+[29; 50) '&[0, b...b'\n']': &[u8]
+[30; 50) '[0, b'...b'\n']': [u8]
+[31; 32) '0': u8
+[34; 39) 'b'\n'': u8
+[41; 42) '1': u8
+[44; 49) 'b'\n'': u8"###
    );
 }
 #[test]
 fn infer_std_crash_3() {
    // taken from rustc
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_std_crash_3",
+        infer(r#"
-        r#"
 pub fn compute() {
    match _ {
        SizeSkeleton::Pointer { non_zero: true, tail } => {}
    }
 }
-"#,
+"#),
+        @r###"
+[18; 102) '{     ...   } }': ()
+[24; 100) 'match ...     }': ()
+[42; 88) 'SizeSk...tail }': {unknown}
+[76; 80) 'true': {unknown}
+[82; 86) 'tail': {unknown}
+[92; 94) '{}': ()"###
    );
 }
 #[test]
 fn infer_std_crash_4() {
    // taken from rustc
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_std_crash_4",
+        infer(r#"
-        r#"
 pub fn primitive_type() {
    match *self {
        BorrowedRef { type_: box Primitive(p), ..} => {},
    }
 }
-"#,
+"#),
+        @r###"
+[25; 110) '{     ...   } }': ()
+[31; 108) 'match ...     }': ()
+[37; 42) '*self': {unknown}
+[38; 42) 'self': {unknown}
+[53; 95) 'Borrow...), ..}': {unknown}
+[74; 77) 'box': {unknown}
+[78; 87) 'Primitive': {unknown}
+[88; 89) 'p': {unknown}
+[99; 101) '{}': ()"###
    );
 }
 #[test]
 fn infer_std_crash_5() {
    // taken from rustc
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_std_crash_5",
+        infer(r#"
-        r#"
 fn extra_compiler_flags() {
    for content in doesnt_matter {
        let name = if doesnt_matter {
@@ -957,16 +1684,39 @@ fn extra_compiler_flags() {
        };
    }
 }
-"#,
+"#),
+        @r###"
+[27; 323) '{     ...   } }': ()
+[33; 321) 'for co...     }': ()
+[37; 44) 'content': &{unknown}
+[48; 61) 'doesnt_matter': {unknown}
+[62; 321) '{     ...     }': ()
+[76; 80) 'name': &&{unknown}
+[83; 167) 'if doe...     }': &&{unknown}
+[86; 99) 'doesnt_matter': bool
+[100; 129) '{     ...     }': &&{unknown}
+[114; 119) 'first': &&{unknown}
+[135; 167) '{     ...     }': &&{unknown}
+[149; 157) '&content': &&{unknown}
+[150; 157) 'content': &{unknown}
+[182; 189) 'content': &&{unknown}
+[192; 314) 'if ICE...     }': &&{unknown}
+[195; 232) 'ICE_RE..._VALUE': {unknown}
+[195; 248) 'ICE_RE...&name)': bool
+[242; 247) '&name': &&&{unknown}
+[243; 247) 'name': &&{unknown}
+[249; 277) '{     ...     }': &&{unknown}
+[263; 267) 'name': &&{unknown}
+[283; 314) '{     ...     }': &{unknown}
+[297; 304) 'content': &{unknown}"###
    );
 }
 #[test]
 fn infer_nested_generics_crash() {
    // another crash found typechecking rustc
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_nested_generics_crash",
+        infer(r#"
-        r#"
 struct Canonical<V> {
    value: V,
 }
@@ -976,7 +1726,13 @@ struct QueryResponse<V> {
 fn test<R>(query_response: Canonical<QueryResponse<R>>) {
    &query_response.value;
 }
-"#,
+"#),
+        @r###"
+[92; 106) 'query_response': Canonical<QueryResponse<R>>
+[137; 167) '{     ...lue; }': ()
+[143; 164) '&query....value': &QueryResponse<R>
+[144; 158) 'query_response': Canonical<QueryResponse<R>>
+[144; 164) 'query_....value': QueryResponse<R>"###
    );
 }
@@ -1008,9 +1764,8 @@ mod foo {
 #[test]
 fn infer_const() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_const",
+        infer(r#"
-        r#"
 struct Foo;
 impl Foo { const ASSOC_CONST: u32 = 0; }
 const GLOBAL_CONST: u32 = 101;
@@ -1020,15 +1775,22 @@ fn test() {
    let z = GLOBAL_CONST;
    let id = Foo::ASSOC_CONST;
 }
-"#,
+"#),
+        @r###"
+[95; 213) '{     ...NST; }': ()
+[138; 139) 'x': {unknown}
+[142; 153) 'LOCAL_CONST': {unknown}
+[163; 164) 'z': u32
+[167; 179) 'GLOBAL_CONST': u32
+[189; 191) 'id': u32
+[194; 210) 'Foo::A..._CONST': u32"###
    );
 }
 #[test]
 fn infer_static() {
-    check_inference(
+    assert_snapshot_matches!(
-        "infer_static",
+        infer(r#"
-        r#"
 static GLOBAL_STATIC: u32 = 101;
 static mut GLOBAL_STATIC_MUT: u32 = 101;
 fn test() {
@@ -1039,17 +1801,346 @@ fn test() {
    let z = GLOBAL_STATIC;
    let w = GLOBAL_STATIC_MUT;
 }
-"#,
+"#),
+        @r###"
+[85; 280) '{     ...MUT; }': ()
+[173; 174) 'x': {unknown}
+[177; 189) 'LOCAL_STATIC': {unknown}
+[199; 200) 'y': {unknown}
+[203; 219) 'LOCAL_...IC_MUT': {unknown}
+[229; 230) 'z': u32
+[233; 246) 'GLOBAL_STATIC': u32
+[256; 257) 'w': u32
+[260; 277) 'GLOBAL...IC_MUT': u32"###
+    );
+}
+#[test]
+fn infer_trait_method_simple() {
+    // the trait implementation is intentionally incomplete -- it shouldn't matter
+    assert_snapshot_matches!(
+        infer(r#"
+trait Trait1 {
+    fn method(&self) -> u32;
+}
+struct S1;
+impl Trait1 for S1 {}
+trait Trait2 {
+    fn method(&self) -> i128;
+}
+struct S2;
+impl Trait2 for S2 {}
+fn test() {
+    S1.method(); // -> u32
+    S2.method(); // -> i128
+}
+"#),
+        @r###"
+[31; 35) 'self': &{unknown}
+[110; 114) 'self': &{unknown}
+[170; 228) '{     ...i128 }': ()
+[176; 178) 'S1': S1
+[176; 187) 'S1.method()': {unknown}
+[203; 205) 'S2': S2
+[203; 214) 'S2.method()': {unknown}"###
+    );
+}
+#[test]
+fn infer_trait_method_scoped() {
+    // the trait implementation is intentionally incomplete -- it shouldn't matter
+    assert_snapshot_matches!(
+        infer(r#"
+struct S;
+mod foo {
+    pub trait Trait1 {
+        fn method(&self) -> u32;
+    }
+    impl Trait1 for super::S {}
+}
+mod bar {
+    pub trait Trait2 {
+        fn method(&self) -> i128;
+    }
+    impl Trait2 for super::S {}
+}
+mod foo_test {
+    use super::S;
+    use super::foo::Trait1;
+    fn test() {
+        S.method(); // -> u32
+    }
+}
+mod bar_test {
+    use super::S;
+    use super::bar::Trait2;
+    fn test() {
+        S.method(); // -> i128
+    }
+}
+"#),
+        @r###"
+[63; 67) 'self': &{unknown}
+[169; 173) 'self': &{unknown}
+[300; 337) '{     ...     }': ()
+[310; 311) 'S': S
+[310; 320) 'S.method()': {unknown}
+[416; 454) '{     ...     }': ()
+[426; 427) 'S': S
+[426; 436) 'S.method()': {unknown}"###
+    );
+}
+#[test]
+fn infer_trait_method_generic_1() {
+    // the trait implementation is intentionally incomplete -- it shouldn't matter
+    assert_snapshot_matches!(
+        infer(r#"
+trait Trait<T> {
+    fn method(&self) -> T;
+}
+struct S;
+impl Trait<u32> for S {}
+fn test() {
+    S.method();
+}
+"#),
+        @r###"
+[33; 37) 'self': &{unknown}
+[92; 111) '{     ...d(); }': ()
+[98; 99) 'S': S
+[98; 108) 'S.method()': {unknown}"###
+    );
+}
+#[test]
+fn infer_trait_method_generic_2() {
+    // the trait implementation is intentionally incomplete -- it shouldn't matter
+    assert_snapshot_matches!(
+        infer(r#"
+trait Trait<T> {
+    fn method(&self) -> T;
+}
+struct S<T>(T);
+impl<U> Trait<U> for S<U> {}
+fn test() {
+    S(1u32).method();
+}
+"#),
+        @r###"
+[33; 37) 'self': &{unknown}
+[102; 127) '{     ...d(); }': ()
+[108; 109) 'S': S<u32>(T) -> S<T>
+[108; 115) 'S(1u32)': S<u32>
+[108; 124) 'S(1u32...thod()': {unknown}
+[110; 114) '1u32': u32"###
+    );
+}
+#[test]
+fn infer_trait_assoc_method() {
+    assert_snapshot_matches!(
+        infer(r#"
+trait Default {
+    fn default() -> Self;
+}
+struct S;
+impl Default for S {}
+fn test() {
+    let s1: S = Default::default();
+    let s2 = S::default();
+    let s3 = <S as Default>::default();
+}
+"#),
+        @r###"
+[87; 193) '{     ...t(); }': ()
+[97; 99) 's1': S
+[105; 121) 'Defaul...efault': {unknown}
+[105; 123) 'Defaul...ault()': S
+[133; 135) 's2': {unknown}
+[138; 148) 'S::default': {unknown}
+[138; 150) 'S::default()': {unknown}
+[160; 162) 's3': {unknown}
+[165; 188) '<S as ...efault': {unknown}
+[165; 190) '<S as ...ault()': {unknown}"###
+    );
+}
+#[test]
+fn infer_from_bound_1() {
+    assert_snapshot_matches!(
+        infer(r#"
+trait Trait<T> {}
+struct S<T>(T);
+impl<U> Trait<U> for S<U> {}
+fn foo<T: Trait<u32>>(t: T) {}
+fn test() {
+    let s = S(unknown);
+    foo(s);
+}
+"#),
+        @r###"
+[86; 87) 't': T
+[92; 94) '{}': ()
+[105; 144) '{     ...(s); }': ()
+[115; 116) 's': S<{unknown}>
+[119; 120) 'S': S<{unknown}>(T) -> S<T>
+[119; 129) 'S(unknown)': S<{unknown}>
+[121; 128) 'unknown': {unknown}
+[135; 138) 'foo': fn foo<S<{unknown}>>(T) -> ()
+[135; 141) 'foo(s)': ()
+[139; 140) 's': S<{unknown}>"###
+    );
+}
+#[test]
+fn infer_from_bound_2() {
+    assert_snapshot_matches!(
+        infer(r#"
+trait Trait<T> {}
+struct S<T>(T);
+impl<U> Trait<U> for S<U> {}
+fn foo<U, T: Trait<U>>(t: T) -> U {}
+fn test() {
+    let s = S(unknown);
+    let x: u32 = foo(s);
+}
+"#),
+        @r###"
+[87; 88) 't': T
+[98; 100) '{}': ()
+[111; 163) '{     ...(s); }': ()
+[121; 122) 's': S<{unknown}>
+[125; 126) 'S': S<{unknown}>(T) -> S<T>
+[125; 135) 'S(unknown)': S<{unknown}>
+[127; 134) 'unknown': {unknown}
+[145; 146) 'x': u32
+[154; 157) 'foo': fn foo<u32, S<{unknown}>>(T) -> U
+[154; 160) 'foo(s)': u32
+[158; 159) 's': S<{unknown}>"###
+    );
+}
+#[test]
+fn infer_call_trait_method_on_generic_param_1() {
+    assert_snapshot_matches!(
+        infer(r#"
+trait Trait {
+    fn method() -> u32;
+}
+fn test<T: Trait>(t: T) {
+    t.method();
+}
+"#),
+        @r###"
+[59; 60) 't': T
+[65; 84) '{     ...d(); }': ()
+[71; 72) 't': T
+[71; 81) 't.method()': {unknown}"###
+    );
+}
+#[test]
+fn infer_call_trait_method_on_generic_param_2() {
+    assert_snapshot_matches!(
+        infer(r#"
+trait Trait<T> {
+    fn method() -> T;
+}
+fn test<U, T: Trait<U>>(t: T) {
+    t.method();
+}
+"#),
+        @r###"
+[66; 67) 't': T
+[72; 91) '{     ...d(); }': ()
+[78; 79) 't': T
+[78; 88) 't.method()': {unknown}"###
+    );
+}
+#[test]
+fn infer_with_multiple_trait_impls() {
+    assert_snapshot_matches!(
+        infer(r#"
+trait Into<T> {
+    fn into(self) -> T;
+}
+struct S;
+impl Into<u32> for S;
+impl Into<u64> for S;
+fn test() {
+    let x: u32 = S.into();
+    let y: u64 = S.into();
+    let z = Into::<u64>::into(S);
+}
+"#),
+        @r###"
+[29; 33) 'self': {unknown}
+[107; 198) '{     ...(S); }': ()
+[117; 118) 'x': u32
+[126; 127) 'S': S
+[126; 134) 'S.into()': u32
+[144; 145) 'y': u64
+[153; 154) 'S': S
+[153; 161) 'S.into()': u64
+[171; 172) 'z': {unknown}
+[175; 192) 'Into::...::into': {unknown}
+[175; 195) 'Into::...nto(S)': {unknown}
+[193; 194) 'S': S"###
+    );
+}
+#[test]
+fn infer_project_associated_type() {
+    assert_snapshot_matches!(
+        infer(r#"
+trait Iterable {
+   type Item;
+}
+struct S;
+impl Iterable for S { type Item = u32; }
+fn test<T: Iterable>() {
+    let x: <S as Iterable>::Item = 1;
+    let y: T::Item = no_matter;
+}
+"#),
+        @r###"
+[108; 181) '{     ...ter; }': ()
+[118; 119) 'x': i32
+[145; 146) '1': i32
+[156; 157) 'y': {unknown}
+[169; 178) 'no_matter': {unknown}"###
+    );
+}
+#[test]
+fn infer_associated_type_bound() {
+    assert_snapshot_matches!(
+        infer(r#"
+trait Iterable {
+   type Item;
+}
+fn test<T: Iterable<Item=u32>>() {
+    let y: T::Item = unknown;
+}
+"#),
+        @r###"
+[67; 100) '{     ...own; }': ()
+[77; 78) 'y': {unknown}
+[90; 97) 'unknown': {unknown}"###
    );
 }
 fn type_at_pos(db: &MockDatabase, pos: FilePosition) -> String {
    let func = source_binder::function_from_position(db, pos).unwrap();
-    let body_syntax_mapping = func.body_syntax_mapping(db);
+    let body_source_map = func.body_source_map(db);
    let inference_result = func.infer(db);
    let (_, syntax) = func.source(db);
    let node = algo::find_node_at_offset::<ast::Expr>(syntax.syntax(), pos.offset).unwrap();
-    let expr = body_syntax_mapping.node_expr(node).unwrap();
+    let expr = body_source_map.node_expr(node).unwrap();
    let ty = &inference_result[expr];
    ty.to_string()
 }
@@ -1058,20 +2149,21 @@ fn infer(content: &str) -> String {
    let (db, _, file_id) = MockDatabase::with_single_file(content);
    let source_file = db.parse(file_id);
    let mut acc = String::new();
+    acc.push_str("\n");
    for fn_def in source_file.syntax().descendants().filter_map(ast::FnDef::cast) {
        let func = source_binder::function_from_source(&db, file_id, fn_def).unwrap();
        let inference_result = func.infer(&db);
-        let body_syntax_mapping = func.body_syntax_mapping(&db);
+        let body_source_map = func.body_source_map(&db);
        let mut types = Vec::new();
        for (pat, ty) in inference_result.type_of_pat.iter() {
-            let syntax_ptr = match body_syntax_mapping.pat_syntax(pat) {
+            let syntax_ptr = match body_source_map.pat_syntax(pat) {
                Some(sp) => sp,
                None => continue,
            };
            types.push((syntax_ptr, ty));
        }
        for (expr, ty) in inference_result.type_of_expr.iter() {
-            let syntax_ptr = match body_syntax_mapping.expr_syntax(expr) {
+            let syntax_ptr = match body_source_map.expr_syntax(expr) {
                Some(sp) => sp,
                None => continue,
            };
@@ -1091,15 +2183,10 @@ fn infer(content: &str) -> String {
            .unwrap();
        }
    }
+    acc.truncate(acc.trim_end().len());
    acc
 }
-fn check_inference(name: &str, content: &str) {
-    let result = infer(content);
-    insta::assert_snapshot_matches!(&name, &result);
-}
 fn ellipsize(mut text: String, max_len: usize) -> String {
    if text.len() <= max_len {
        return text;
diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs
index 3f041f9c3..0c90ed5b5 100644
--- a/crates/ra_ide_api/src/change.rs
+++ b/crates/ra_ide_api/src/change.rs
@@ -223,8 +223,7 @@ impl RootDatabase {
        self.query(hir::db::FileItemsQuery).sweep(sweep);
        self.query(hir::db::FileItemQuery).sweep(sweep);
-        self.query(hir::db::LowerModuleQuery).sweep(sweep);
+        self.query(hir::db::LowerModuleWithSourceMapQuery).sweep(sweep);
-        self.query(hir::db::LowerModuleSourceMapQuery).sweep(sweep);
+        self.query(hir::db::BodyWithSourceMapQuery).sweep(sweep);
-        self.query(hir::db::BodySyntaxMappingQuery).sweep(sweep);
    }
 }
diff --git a/crates/ra_ide_api/src/completion/complete_dot.rs b/crates/ra_ide_api/src/completion/complete_dot.rs
index d5ad2e79f..94c66be31 100644
--- a/crates/ra_ide_api/src/completion/complete_dot.rs
+++ b/crates/ra_ide_api/src/completion/complete_dot.rs
@@ -9,8 +9,8 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
        _ => return,
    };
    let infer_result = function.infer(ctx.db);
-    let syntax_mapping = function.body_syntax_mapping(ctx.db);
+    let source_map = function.body_source_map(ctx.db);
-    let expr = match syntax_mapping.node_expr(receiver) {
+    let expr = match source_map.node_expr(receiver) {
        Some(expr) => expr,
        None => return,
    };
diff --git a/crates/ra_ide_api/src/completion/complete_struct_literal.rs b/crates/ra_ide_api/src/completion/complete_struct_literal.rs
index afb092f59..6bef9624e 100644
--- a/crates/ra_ide_api/src/completion/complete_struct_literal.rs
+++ b/crates/ra_ide_api/src/completion/complete_struct_literal.rs
@@ -9,8 +9,8 @@ pub(super) fn complete_struct_literal(acc: &mut Completions, ctx: &CompletionCon
        _ => return,
    };
    let infer_result = function.infer(ctx.db);
-    let syntax_mapping = function.body_syntax_mapping(ctx.db);
+    let source_map = function.body_source_map(ctx.db);
-    let expr = match syntax_mapping.node_expr(struct_lit.into()) {
+    let expr = match source_map.node_expr(struct_lit.into()) {
        Some(expr) => expr,
        None => return,
    };
diff --git a/crates/ra_ide_api/src/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
index 6fa430754..9ec179593 100644
--- a/crates/ra_ide_api/src/goto_definition.rs
+++ b/crates/ra_ide_api/src/goto_definition.rs
@@ -54,10 +54,10 @@ pub(crate) fn reference_definition(
        if let Some(method_call) = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast) {
            tested_by!(goto_definition_works_for_methods);
            let infer_result = function.infer(db);
-            let syntax_mapping = function.body_syntax_mapping(db);
+            let source_map = function.body_source_map(db);
            let expr = ast::Expr::cast(method_call.syntax()).unwrap();
            if let Some(func) =
-                syntax_mapping.node_expr(expr).and_then(|it| infer_result.method_resolution(it))
+                source_map.node_expr(expr).and_then(|it| infer_result.method_resolution(it))
            {
                return Exact(NavigationTarget::from_function(db, func));
            };
@@ -66,10 +66,10 @@ pub(crate) fn reference_definition(
        if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::FieldExpr::cast) {
            tested_by!(goto_definition_works_for_fields);
            let infer_result = function.infer(db);
-            let syntax_mapping = function.body_syntax_mapping(db);
+            let source_map = function.body_source_map(db);
            let expr = ast::Expr::cast(field_expr.syntax()).unwrap();
            if let Some(field) =
-                syntax_mapping.node_expr(expr).and_then(|it| infer_result.field_resolution(it))
+                source_map.node_expr(expr).and_then(|it| infer_result.field_resolution(it))
            {
                return Exact(NavigationTarget::from_field(db, field));
            };
@@ -80,11 +80,11 @@ pub(crate) fn reference_definition(
            tested_by!(goto_definition_works_for_named_fields);
            let infer_result = function.infer(db);
-            let syntax_mapping = function.body_syntax_mapping(db);
+            let source_map = function.body_source_map(db);
            let struct_lit = field_expr.syntax().ancestors().find_map(ast::StructLit::cast);
-            if let Some(expr) = struct_lit.and_then(|lit| syntax_mapping.node_expr(lit.into())) {
+            if let Some(expr) = struct_lit.and_then(|lit| source_map.node_expr(lit.into())) {
                let ty = infer_result[expr].clone();
                if let hir::Ty::Adt { def_id, .. } = ty {
                    if let hir::AdtDef::Struct(s) = def_id {
@@ -109,9 +109,8 @@ pub(crate) fn reference_definition(
            Some(Resolution::Def(def)) => return Exact(NavigationTarget::from_def(db, def)),
            Some(Resolution::LocalBinding(pat)) => {
                let body = resolver.body().expect("no body for local binding");
-                let syntax_mapping = body.syntax_mapping(db);
+                let source_map = body.owner().body_source_map(db);
-                let ptr =
+                let ptr = source_map.pat_syntax(pat).expect("pattern not found in syntax mapping");
-                    syntax_mapping.pat_syntax(pat).expect("pattern not found in syntax mapping");
                let name =
                    path.as_ident().cloned().expect("local binding from a multi-segment path");
                let nav = NavigationTarget::from_scope_entry(file_id, name, ptr);
diff --git a/crates/ra_ide_api/src/hover.rs b/crates/ra_ide_api/src/hover.rs
index 1a1853df3..8ec60090d 100644
--- a/crates/ra_ide_api/src/hover.rs
+++ b/crates/ra_ide_api/src/hover.rs
@@ -107,7 +107,7 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
            leaf.ancestors().find(|n| ast::Expr::cast(*n).is_some() || ast::Pat::cast(*n).is_some())
        })?;
        let frange = FileRange { file_id: position.file_id, range: node.range() };
-        res.extend(type_of(db, frange).map(Into::into));
+        res.extend(type_of(db, frange).map(rust_code_markup));
        range = Some(node.range());
    }
@@ -132,22 +132,37 @@ pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
    let parent_fn = node.ancestors().find_map(ast::FnDef::cast)?;
    let function = hir::source_binder::function_from_source(db, frange.file_id, parent_fn)?;
    let infer = function.infer(db);
-    let syntax_mapping = function.body_syntax_mapping(db);
+    let source_map = function.body_source_map(db);
-    if let Some(expr) = ast::Expr::cast(node).and_then(|e| syntax_mapping.node_expr(e)) {
+    if let Some(expr) = ast::Expr::cast(node).and_then(|e| source_map.node_expr(e)) {
        Some(infer[expr].to_string())
-    } else if let Some(pat) = ast::Pat::cast(node).and_then(|p| syntax_mapping.node_pat(p)) {
+    } else if let Some(pat) = ast::Pat::cast(node).and_then(|p| source_map.node_pat(p)) {
        Some(infer[pat].to_string())
    } else {
        None
    }
 }
+fn rust_code_markup<CODE: AsRef<str>>(val: CODE) -> String {
+    rust_code_markup_with_doc::<_, &str>(val, None)
+}
+fn rust_code_markup_with_doc<CODE, DOC>(val: CODE, doc: Option<DOC>) -> String
+where
+    CODE: AsRef<str>,
+    DOC: AsRef<str>,
+{
+    if let Some(doc) = doc {
+        format!("```rust\n{}\n```\n\n{}", val.as_ref(), doc.as_ref())
+    } else {
+        format!("```rust\n{}\n```", val.as_ref())
+    }
+}
 // FIXME: this should not really use navigation target. Rather, approximately
 // resolved symbol should return a `DefId`.
 fn doc_text_for(db: &RootDatabase, nav: NavigationTarget) -> Option<String> {
    match (nav.description(db), nav.docs(db)) {
-        (Some(desc), Some(docs)) => Some("```rust\n".to_string() + &*desc + "\n```\n\n" + &*docs),
+        (Some(desc), docs) => Some(rust_code_markup_with_doc(desc, docs)),
-        (Some(desc), None) => Some("```rust\n".to_string() + &*desc + "\n```"),
        (None, Some(docs)) => Some(docs),
        _ => None,
    }
@@ -238,6 +253,10 @@ mod tests {
        s.trim_start_matches("```rust\n").trim_end_matches("\n```")
    }
+    fn trim_markup_opt(s: Option<&str>) -> Option<&str> {
+        s.map(trim_markup)
+    }
    fn check_hover_result(fixture: &str, expected: &[&str]) {
        let (analysis, position) = analysis_and_position(fixture);
        let hover = analysis.hover(position).unwrap().unwrap();
@@ -264,7 +283,7 @@ mod tests {
        );
        let hover = analysis.hover(position).unwrap().unwrap();
        assert_eq!(hover.range, TextRange::from_to(95.into(), 100.into()));
-        assert_eq!(hover.info.first(), Some("u32"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("u32"));
    }
    #[test]
@@ -410,21 +429,21 @@ mod tests {
        );
        let hover = analysis.hover(position).unwrap().unwrap();
        // not the nicest way to show it currently
-        assert_eq!(hover.info.first(), Some("Some<i32>(T) -> Option<T>"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("Some<i32>(T) -> Option<T>"));
    }
    #[test]
    fn hover_for_local_variable() {
        let (analysis, position) = single_file_with_position("fn func(foo: i32) { fo<|>o; }");
        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(hover.info.first(), Some("i32"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
    }
    #[test]
    fn hover_for_local_variable_pat() {
        let (analysis, position) = single_file_with_position("fn func(fo<|>o: i32) {}");
        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(hover.info.first(), Some("i32"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
    }
    #[test]
@@ -455,7 +474,7 @@ mod tests {
        );
        let type_name = analysis.type_of(range).unwrap().unwrap();
-        assert_eq!("[unknown]", &type_name);
+        assert_eq!("{unknown}", &type_name);
    }
    #[test]
@@ -491,6 +510,6 @@ mod tests {
            ",
        );
        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(hover.info.first(), Some("Thing"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("Thing"));
    }
 }
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index 6546d0644..b8a4adbce 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -32,13 +32,14 @@ mod references;
 mod impls;
 mod assists;
 mod diagnostics;
+mod syntax_tree;
 #[cfg(test)]
 mod marks;
 use std::sync::Arc;
-use ra_syntax::{SourceFile, TreeArc, TextRange, TextUnit, AstNode};
+use ra_syntax::{SourceFile, TreeArc, TextRange, TextUnit};
 use ra_text_edit::TextEdit;
 use ra_db::{
    SourceDatabase, CheckCanceled,
@@ -245,8 +246,8 @@ impl Analysis {
    /// Returns a syntax tree represented as `String`, for debug purposes.
    // FIXME: use a better name here.
-    pub fn syntax_tree(&self, file_id: FileId) -> String {
+    pub fn syntax_tree(&self, file_id: FileId, text_range: Option<TextRange>) -> String {
-        self.db.parse(file_id).syntax().debug_dump()
+        syntax_tree::syntax_tree(&self.db, file_id, text_range)
    }
    /// Returns an edit to remove all newlines in the range, cleaning up minor
diff --git a/crates/ra_ide_api/src/syntax_tree.rs b/crates/ra_ide_api/src/syntax_tree.rs
new file mode 100644
index 000000000..bbe9222b4
--- /dev/null
+++ b/crates/ra_ide_api/src/syntax_tree.rs
@@ -0,0 +1,87 @@
+use ra_db::SourceDatabase;
+use crate::db::RootDatabase;
+use ra_syntax::{
+    SourceFile, SyntaxNode, TextRange, AstNode,
+    algo::{self, visit::{visitor, Visitor}}, ast::{self, AstToken}
+};
+pub use ra_db::FileId;
+pub(crate) fn syntax_tree(
+    db: &RootDatabase,
+    file_id: FileId,
+    text_range: Option<TextRange>,
+) -> String {
+    if let Some(text_range) = text_range {
+        let file = db.parse(file_id);
+        let node = algo::find_covering_node(file.syntax(), text_range);
+        if let Some(tree) = syntax_tree_for_string(node, text_range) {
+            return tree;
+        }
+        node.debug_dump()
+    } else {
+        db.parse(file_id).syntax().debug_dump()
+    }
+}
+/// Attempts parsing the selected contents of a string literal
+/// as rust syntax and returns its syntax tree
+fn syntax_tree_for_string(node: &SyntaxNode, text_range: TextRange) -> Option<String> {
+    // When the range is inside a string
+    // we'll attempt parsing it as rust syntax
+    // to provide the syntax tree of the contents of the string
+    visitor()
+        .visit(|node: &ast::String| syntax_tree_for_token(node, text_range))
+        .visit(|node: &ast::RawString| syntax_tree_for_token(node, text_range))
+        .accept(node)?
+}
+fn syntax_tree_for_token<T: AstToken>(node: &T, text_range: TextRange) -> Option<String> {
+    // Range of the full node
+    let node_range = node.syntax().range();
+    let text = node.text().to_string();
+    // We start at some point inside the node
+    // Either we have selected the whole string
+    // or our selection is inside it
+    let start = text_range.start() - node_range.start();
+    // how many characters we have selected
+    let len = text_range.len().to_usize();
+    let node_len = node_range.len().to_usize();
+    let start = start.to_usize();
+    // We want to cap our length
+    let len = len.min(node_len);
+    // Ensure our slice is inside the actual string
+    let end = if start + len < text.len() { start + len } else { text.len() - start };
+    let text = &text[start..end];
+    // Remove possible extra string quotes from the start
+    // and the end of the string
+    let text = text
+        .trim_start_matches('r')
+        .trim_start_matches('#')
+        .trim_start_matches('"')
+        .trim_end_matches('#')
+        .trim_end_matches('"')
+        .trim()
+        // Remove custom markers
+        .replace("<|>", "");
+    let parsed = SourceFile::parse(&text);
+    // If the "file" parsed without errors,
+    // return its syntax
+    if parsed.errors().is_empty() {
+        return Some(parsed.syntax().debug_dump());
+    }
+    None
+}
diff --git a/crates/ra_ide_api/tests/test/main.rs b/crates/ra_ide_api/tests/test/main.rs
index ff1a0e46b..0f0766f62 100644
--- a/crates/ra_ide_api/tests/test/main.rs
+++ b/crates/ra_ide_api/tests/test/main.rs
@@ -1,6 +1,6 @@
 use insta::assert_debug_snapshot_matches;
 use ra_ide_api::{
-    mock_analysis::{single_file, single_file_with_position, MockAnalysis},
+    mock_analysis::{single_file, single_file_with_position, single_file_with_range, MockAnalysis},
    AnalysisChange, CrateGraph, Edition::Edition2018, Query, NavigationTarget,
    ReferenceSearchResult,
 };
@@ -138,3 +138,255 @@ mod foo {
    assert_eq!(s.name(), "FooInner");
    assert_eq!(s.container_name(), Some(&SmolStr::new("foo")));
 }
+#[test]
+fn test_syntax_tree_without_range() {
+    // Basic syntax
+    let (analysis, file_id) = single_file(r#"fn foo() {}"#);
+    let syn = analysis.syntax_tree(file_id, None);
+    assert_eq!(
+        syn.trim(),
+        r#"
+SOURCE_FILE@[0; 11)
+  FN_DEF@[0; 11)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK@[9; 11)
+      L_CURLY@[9; 10)
+      R_CURLY@[10; 11)
+    "#
+        .trim()
+    );
+    let (analysis, file_id) = single_file(
+        r#"
+fn test() {
+    assert!("
+    fn foo() {
+    }
+    ", "");
+}"#
+        .trim(),
+    );
+    let syn = analysis.syntax_tree(file_id, None);
+    assert_eq!(
+        syn.trim(),
+        r#"
+SOURCE_FILE@[0; 60)
+  FN_DEF@[0; 60)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "test"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK@[10; 60)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      EXPR_STMT@[16; 58)
+        MACRO_CALL@[16; 57)
+          PATH@[16; 22)
+            PATH_SEGMENT@[16; 22)
+              NAME_REF@[16; 22)
+                IDENT@[16; 22) "assert"
+          EXCL@[22; 23)
+          TOKEN_TREE@[23; 57)
+            L_PAREN@[23; 24)
+            STRING@[24; 52)
+            COMMA@[52; 53)
+            WHITESPACE@[53; 54)
+            STRING@[54; 56)
+            R_PAREN@[56; 57)
+        SEMI@[57; 58)
+      WHITESPACE@[58; 59)
+      R_CURLY@[59; 60)
+    "#
+        .trim()
+    );
+}
+#[test]
+fn test_syntax_tree_with_range() {
+    let (analysis, range) = single_file_with_range(r#"<|>fn foo() {}<|>"#.trim());
+    let syn = analysis.syntax_tree(range.file_id, Some(range.range));
+    assert_eq!(
+        syn.trim(),
+        r#"
+FN_DEF@[0; 11)
+  FN_KW@[0; 2)
+  WHITESPACE@[2; 3)
+  NAME@[3; 6)
+    IDENT@[3; 6) "foo"
+  PARAM_LIST@[6; 8)
+    L_PAREN@[6; 7)
+    R_PAREN@[7; 8)
+  WHITESPACE@[8; 9)
+  BLOCK@[9; 11)
+    L_CURLY@[9; 10)
+    R_CURLY@[10; 11)
+    "#
+        .trim()
+    );
+    let (analysis, range) = single_file_with_range(
+        r#"fn test() {
+    <|>assert!("
+    fn foo() {
+    }
+    ", "");<|>
+}"#
+        .trim(),
+    );
+    let syn = analysis.syntax_tree(range.file_id, Some(range.range));
+    assert_eq!(
+        syn.trim(),
+        r#"
+EXPR_STMT@[16; 58)
+  MACRO_CALL@[16; 57)
+    PATH@[16; 22)
+      PATH_SEGMENT@[16; 22)
+        NAME_REF@[16; 22)
+          IDENT@[16; 22) "assert"
+    EXCL@[22; 23)
+    TOKEN_TREE@[23; 57)
+      L_PAREN@[23; 24)
+      STRING@[24; 52)
+      COMMA@[52; 53)
+      WHITESPACE@[53; 54)
+      STRING@[54; 56)
+      R_PAREN@[56; 57)
+  SEMI@[57; 58)
+    "#
+        .trim()
+    );
+}
+#[test]
+fn test_syntax_tree_inside_string() {
+    let (analysis, range) = single_file_with_range(
+        r#"fn test() {
+    assert!("
+<|>fn foo() {
+}<|>
+fn bar() {
+}
+    ", "");
+}"#
+        .trim(),
+    );
+    let syn = analysis.syntax_tree(range.file_id, Some(range.range));
+    assert_eq!(
+        syn.trim(),
+        r#"
+SOURCE_FILE@[0; 12)
+  FN_DEF@[0; 12)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK@[9; 12)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 11)
+      R_CURLY@[11; 12)
+"#
+        .trim()
+    );
+    // With a raw string
+    let (analysis, range) = single_file_with_range(
+        r###"fn test() {
+    assert!(r#"
+<|>fn foo() {
+}<|>
+fn bar() {
+}
+    "#, "");
+}"###
+            .trim(),
+    );
+    let syn = analysis.syntax_tree(range.file_id, Some(range.range));
+    assert_eq!(
+        syn.trim(),
+        r#"
+SOURCE_FILE@[0; 12)
+  FN_DEF@[0; 12)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK@[9; 12)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 11)
+      R_CURLY@[11; 12)
+"#
+        .trim()
+    );
+    // With a raw string
+    let (analysis, range) = single_file_with_range(
+        r###"fn test() {
+    assert!(r<|>#"
+fn foo() {
+}
+fn bar() {
+}"<|>#, "");
+}"###
+            .trim(),
+    );
+    let syn = analysis.syntax_tree(range.file_id, Some(range.range));
+    assert_eq!(
+        syn.trim(),
+        r#"
+SOURCE_FILE@[0; 25)
+  FN_DEF@[0; 12)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK@[9; 12)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 11)
+      R_CURLY@[11; 12)
+  WHITESPACE@[12; 13)
+  FN_DEF@[13; 25)
+    FN_KW@[13; 15)
+    WHITESPACE@[15; 16)
+    NAME@[16; 19)
+      IDENT@[16; 19) "bar"
+    PARAM_LIST@[19; 21)
+      L_PAREN@[19; 20)
+      R_PAREN@[20; 21)
+    WHITESPACE@[21; 22)
+    BLOCK@[22; 25)
+      L_CURLY@[22; 23)
+      WHITESPACE@[23; 24)
+      R_CURLY@[24; 25)
+"#
+        .trim()
+    );
+}
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index dce6fcc67..89e96a33a 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -32,7 +32,9 @@ pub fn handle_analyzer_status(world: ServerWorld, _: ()) -> Result<String> {
 pub fn handle_syntax_tree(world: ServerWorld, params: req::SyntaxTreeParams) -> Result<String> {
    let id = params.text_document.try_conv_with(&world)?;
-    let res = world.analysis().syntax_tree(id);
+    let line_index = world.analysis().file_line_index(id);
+    let text_range = params.range.map(|p| p.conv_with(&line_index));
+    let res = world.analysis().syntax_tree(id, text_range);
    Ok(res)
 }
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index e224ede80..5c589f969 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -39,6 +39,7 @@ impl Request for SyntaxTree {
 #[serde(rename_all = "camelCase")]
 pub struct SyntaxTreeParams {
    pub text_document: TextDocumentIdentifier,
+    pub range: Option<Range>,
 }
 pub enum ExtendSelection {}
diff --git a/editors/code/package.json b/editors/code/package.json
index d4ce2ae2c..fda411810 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -75,7 +75,7 @@
        "commands": [
            {
                "command": "rust-analyzer.syntaxTree",
-                "title": "Show syntax tree for current file",
+                "title": "Show Syntax Tree",
                "category": "Rust Analyzer"
            },
            {
diff --git a/editors/code/src/commands/syntaxTree.ts b/editors/code/src/commands/syntaxTree.ts
index c0baf08c5..2f50fe14b 100644
--- a/editors/code/src/commands/syntaxTree.ts
+++ b/editors/code/src/commands/syntaxTree.ts
@@ -1,11 +1,11 @@
 import * as vscode from 'vscode';
-import { TextDocumentIdentifier } from 'vscode-languageclient';
+import { Range, TextDocumentIdentifier } from 'vscode-languageclient';
 import { Server } from '../server';
 export const syntaxTreeUri = vscode.Uri.parse('rust-analyzer://syntaxtree');
-export class TextDocumentContentProvider
+export class SyntaxTreeContentProvider
    implements vscode.TextDocumentContentProvider {
    public eventEmitter = new vscode.EventEmitter<vscode.Uri>();
    public syntaxTree: string = 'Not available';
@@ -17,8 +17,21 @@ export class TextDocumentContentProvider
        if (editor == null) {
            return '';
        }
+        let range: Range | undefined;
+        // When the range based query is enabled we take the range of the selection
+        if (uri.query === 'range=true') {
+            range = editor.selection.isEmpty
+                ? undefined
+                : Server.client.code2ProtocolConverter.asRange(
+                      editor.selection
+                  );
+        }
        const request: SyntaxTreeParams = {
-            textDocument: { uri: editor.document.uri.toString() }
+            textDocument: { uri: editor.document.uri.toString() },
+            range
        };
        return Server.client.sendRequest<SyntaxTreeResult>(
            'rust-analyzer/syntaxTree',
@@ -33,6 +46,7 @@ export class TextDocumentContentProvider
 interface SyntaxTreeParams {
    textDocument: TextDocumentIdentifier;
+    range?: Range;
 }
 type SyntaxTreeResult = string;
@@ -40,11 +54,23 @@ type SyntaxTreeResult = string;
 // Opens the virtual file that will show the syntax tree
 //
 // The contents of the file come from the `TextDocumentContentProvider`
-export async function handle() {
+export function createHandle(provider: SyntaxTreeContentProvider) {
-    const document = await vscode.workspace.openTextDocument(syntaxTreeUri);
+    return async () => {
-    return vscode.window.showTextDocument(
+        const editor = vscode.window.activeTextEditor;
-        document,
+        const rangeEnabled = !!(editor && !editor.selection.isEmpty);
-        vscode.ViewColumn.Two,
-        true
+        const uri = rangeEnabled
-    );
+            ? vscode.Uri.parse(`${syntaxTreeUri.toString()}?range=true`)
+            : syntaxTreeUri;
+        const document = await vscode.workspace.openTextDocument(uri);
+        provider.eventEmitter.fire(uri);
+        return vscode.window.showTextDocument(
+            document,
+            vscode.ViewColumn.Two,
+            true
+        );
+    };
 }
diff --git a/editors/code/src/events/change_active_text_editor.ts b/editors/code/src/events/change_active_text_editor.ts
index af295b2ec..64be56225 100644
--- a/editors/code/src/events/change_active_text_editor.ts
+++ b/editors/code/src/events/change_active_text_editor.ts
@@ -1,23 +1,32 @@
 import { TextEditor } from 'vscode';
 import { TextDocumentIdentifier } from 'vscode-languageclient';
+import {
+    SyntaxTreeContentProvider,
+    syntaxTreeUri
+} from '../commands/syntaxTree';
 import { Decoration } from '../highlighting';
 import { Server } from '../server';
-export async function handle(editor: TextEditor | undefined) {
+export function makeHandler(syntaxTreeProvider: SyntaxTreeContentProvider) {
-    if (
+    return async function handle(editor: TextEditor | undefined) {
-        !Server.config.highlightingOn ||
+        if (!editor || editor.document.languageId !== 'rust') {
-        !editor ||
+            return;
-        editor.document.languageId !== 'rust'
+        }
-    ) {
-        return;
+        syntaxTreeProvider.eventEmitter.fire(syntaxTreeUri);
-    }
-    const params: TextDocumentIdentifier = {
+        if (!Server.config.highlightingOn) {
-        uri: editor.document.uri.toString()
+            return;
+        }
+        const params: TextDocumentIdentifier = {
+            uri: editor.document.uri.toString()
+        };
+        const decorations = await Server.client.sendRequest<Decoration[]>(
+            'rust-analyzer/decorationsRequest',
+            params
+        );
+        Server.highlighter.setHighlights(editor, decorations);
    };
-    const decorations = await Server.client.sendRequest<Decoration[]>(
-        'rust-analyzer/decorationsRequest',
-        params
-    );
-    Server.highlighter.setHighlights(editor, decorations);
 }
diff --git a/editors/code/src/events/change_text_document.ts b/editors/code/src/events/change_text_document.ts
index 6be057245..89488bc61 100644
--- a/editors/code/src/events/change_text_document.ts
+++ b/editors/code/src/events/change_text_document.ts
@@ -1,20 +1,18 @@
 import * as vscode from 'vscode';
 import {
-    syntaxTreeUri,
+    SyntaxTreeContentProvider,
-    TextDocumentContentProvider
+    syntaxTreeUri
 } from '../commands/syntaxTree';
-export function createHandler(
+export function createHandler(syntaxTreeProvider: SyntaxTreeContentProvider) {
-    textDocumentContentProvider: TextDocumentContentProvider
-) {
    return (event: vscode.TextDocumentChangeEvent) => {
        const doc = event.document;
        if (doc.languageId !== 'rust') {
            return;
        }
        afterLs(() => {
-            textDocumentContentProvider.eventEmitter.fire(syntaxTreeUri);
+            syntaxTreeProvider.eventEmitter.fire(syntaxTreeUri);
        });
    };
 }
diff --git a/editors/code/src/extension.ts b/editors/code/src/extension.ts
index 8b332eeb2..941beba18 100644
--- a/editors/code/src/extension.ts
+++ b/editors/code/src/extension.ts
@@ -2,7 +2,7 @@ import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 import * as commands from './commands';
-import { TextDocumentContentProvider } from './commands/syntaxTree';
+import { SyntaxTreeContentProvider } from './commands/syntaxTree';
 import * as events from './events';
 import * as notifications from './notifications';
 import { Server } from './server';
@@ -52,7 +52,6 @@ export function activate(context: vscode.ExtensionContext) {
    registerCommand('rust-analyzer.collectGarbage', () =>
        Server.client.sendRequest<null>('rust-analyzer/collectGarbage', null)
    );
-    registerCommand('rust-analyzer.syntaxTree', commands.syntaxTree.handle);
    registerCommand(
        'rust-analyzer.extendSelection',
        commands.extendSelection.handle
@@ -95,22 +94,27 @@ export function activate(context: vscode.ExtensionContext) {
            notifications.publishDecorations.handle
        ]
    ];
+    const syntaxTreeContentProvider = new SyntaxTreeContentProvider();
    // The events below are plain old javascript events, triggered and handled by vscode
    vscode.window.onDidChangeActiveTextEditor(
-        events.changeActiveTextEditor.handle
+        events.changeActiveTextEditor.makeHandler(syntaxTreeContentProvider)
    );
-    const textDocumentContentProvider = new TextDocumentContentProvider();
    disposeOnDeactivation(
        vscode.workspace.registerTextDocumentContentProvider(
            'rust-analyzer',
-            textDocumentContentProvider
+            syntaxTreeContentProvider
        )
    );
+    registerCommand(
+        'rust-analyzer.syntaxTree',
+        commands.syntaxTree.createHandle(syntaxTreeContentProvider)
+    );
    vscode.workspace.onDidChangeTextDocument(
-        events.changeTextDocument.createHandler(textDocumentContentProvider),
+        events.changeTextDocument.createHandler(syntaxTreeContentProvider),
        null,
        context.subscriptions
    );
diff --git a/editors/emacs/ra-emacs-lsp.el b/editors/emacs/ra-emacs-lsp.el
index 4af65c7f0..780182f8a 100644
--- a/editors/emacs/ra-emacs-lsp.el
+++ b/editors/emacs/ra-emacs-lsp.el
@@ -138,7 +138,7 @@
  (add-hook 'rust-mode-hook 'rust-analyzer--add-er-expansion))
 ;; runnables
-(defvar rust-analyzer--last-runnable)
+(defvar rust-analyzer--last-runnable nil)
 (defun rust-analyzer--runnables-params ()
  (list :textDocument (lsp--text-document-identifier)