11 files changed, 90 insertions, 140 deletions
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..78270a9b7 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 }
                }
            }
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 8de46a29e..2fdfb54f4 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -1045,11 +1045,11 @@ fn test() {
 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()
 }
@@ -1061,17 +1061,17 @@ fn infer(content: &str) -> String {
    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,
            };