94 files changed, 2468 insertions, 1904 deletions
diff --git a/crates/ra_arena/src/lib.rs b/crates/ra_arena/src/lib.rs
index 3ec8d3b60..fc0f7c12f 100644
--- a/crates/ra_arena/src/lib.rs
+++ b/crates/ra_arena/src/lib.rs
@@ -37,7 +37,7 @@ impl fmt::Display for RawId {
 }
 #[derive(Clone, PartialEq, Eq)]
-pub struct Arena<ID: ArenaId, T> {
+pub struct Arena<ID, T> {
    data: Vec<T>,
    _ty: PhantomData<ID>,
 }
@@ -67,6 +67,12 @@ pub trait ArenaId {
    fn into_raw(self) -> RawId;
 }
+impl<ID, T> Arena<ID, T> {
+    pub const fn new() -> Arena<ID, T> {
+        Arena { data: Vec::new(), _ty: PhantomData }
+    }
+}
 impl<ID: ArenaId, T> Arena<ID, T> {
    pub fn len(&self) -> usize {
        self.data.len()
@@ -79,7 +85,7 @@ impl<ID: ArenaId, T> Arena<ID, T> {
        self.data.push(value);
        ID::from_raw(id)
    }
-    pub fn iter(&self) -> impl Iterator<Item = (ID, &T)> + ExactSizeIterator {
+    pub fn iter(&self) -> impl Iterator<Item = (ID, &T)> + ExactSizeIterator + DoubleEndedIterator {
        self.data.iter().enumerate().map(|(idx, value)| (ID::from_raw(RawId(idx as u32)), value))
    }
 }
diff --git a/crates/ra_assists/src/assists/add_new.rs b/crates/ra_assists/src/assists/add_new.rs
index b5f8afb4e..ee8bff346 100644
--- a/crates/ra_assists/src/assists/add_new.rs
+++ b/crates/ra_assists/src/assists/add_new.rs
@@ -36,7 +36,7 @@ pub(crate) fn add_new(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
    // We want to only apply this to non-union structs with named fields
    let field_list = match (strukt.kind(), strukt.is_union()) {
-        (StructKind::Named(named), false) => named,
+        (StructKind::Record(named), false) => named,
        _ => return None,
    };
diff --git a/crates/ra_assists/src/assists/apply_demorgan.rs b/crates/ra_assists/src/assists/apply_demorgan.rs
index 068da1774..7c57c0560 100644
--- a/crates/ra_assists/src/assists/apply_demorgan.rs
+++ b/crates/ra_assists/src/assists/apply_demorgan.rs
@@ -1,6 +1,6 @@
+use super::invert_if::invert_boolean_expression;
 use hir::db::HirDatabase;
 use ra_syntax::ast::{self, AstNode};
-use ra_syntax::SyntaxNode;
 use crate::{Assist, AssistCtx, AssistId};
@@ -32,18 +32,18 @@ pub(crate) fn apply_demorgan(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist>
    if !cursor_in_range {
        return None;
    }
-    let lhs = expr.lhs()?.syntax().clone();
+    let lhs = expr.lhs()?;
-    let lhs_range = lhs.text_range();
+    let lhs_range = lhs.syntax().text_range();
-    let rhs = expr.rhs()?.syntax().clone();
+    let rhs = expr.rhs()?;
-    let rhs_range = rhs.text_range();
+    let rhs_range = rhs.syntax().text_range();
-    let not_lhs = undo_negation(lhs)?;
+    let not_lhs = invert_boolean_expression(&lhs)?;
-    let not_rhs = undo_negation(rhs)?;
+    let not_rhs = invert_boolean_expression(&rhs)?;
    ctx.add_assist(AssistId("apply_demorgan"), "apply demorgan's law", |edit| {
        edit.target(op_range);
        edit.replace(op_range, opposite_op);
-        edit.replace(lhs_range, format!("!({}", not_lhs));
+        edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
-        edit.replace(rhs_range, format!("{})", not_rhs));
+        edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
    })
 }
@@ -56,28 +56,6 @@ fn opposite_logic_op(kind: ast::BinOp) -> Option<&'static str> {
    }
 }
-// This function tries to undo unary negation, or inequality
-fn undo_negation(node: SyntaxNode) -> Option<String> {
-    match ast::Expr::cast(node)? {
-        ast::Expr::BinExpr(bin) => match bin.op_kind()? {
-            ast::BinOp::NegatedEqualityTest => {
-                let lhs = bin.lhs()?.syntax().text();
-                let rhs = bin.rhs()?.syntax().text();
-                Some(format!("{} == {}", lhs, rhs))
-            }
-            _ => None,
-        },
-        ast::Expr::PrefixExpr(pe) => match pe.op_kind()? {
-            ast::PrefixOp::Not => {
-                let child = pe.expr()?.syntax().text();
-                Some(String::from(child))
-            }
-            _ => None,
-        },
-        _ => None,
-    }
-}
 #[cfg(test)]
 mod tests {
    use super::*;
diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/assists/fill_match_arms.rs
index 9354466d9..8482897c5 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/assists/fill_match_arms.rs
@@ -101,7 +101,7 @@ fn build_pat(var: ast::EnumVariant) -> Option<ast::Pat> {
                iter::repeat(make::placeholder_pat().into()).take(field_list.fields().count());
            make::tuple_struct_pat(path, pats).into()
        }
-        ast::StructKind::Named(field_list) => {
+        ast::StructKind::Record(field_list) => {
            let pats = field_list.fields().map(|f| make::bind_pat(f.name().unwrap()).into());
            make::record_pat(path, pats).into()
        }
diff --git a/crates/ra_assists/src/assists/invert_if.rs b/crates/ra_assists/src/assists/invert_if.rs
new file mode 100644
index 000000000..bababa3e2
--- /dev/null
+++ b/crates/ra_assists/src/assists/invert_if.rs
@@ -0,0 +1,102 @@
+use hir::db::HirDatabase;
+use ra_syntax::ast::{self, AstNode};
+use ra_syntax::T;
+use crate::{Assist, AssistCtx, AssistId};
+// Assist: invert_if
+//
+// Apply invert_if
+// This transforms if expressions of the form `if !x {A} else {B}` into `if x {B} else {A}`
+// This also works with `!=`. This assist can only be applied with the cursor
+// on `if`.
+//
+// ```
+// fn main() {
+//     if<|> !y { A } else { B }
+// }
+// ```
+// ->
+// ```
+// fn main() {
+//     if y { B } else { A }
+// }
+// ```
+pub(crate) fn invert_if(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let if_keyword = ctx.find_token_at_offset(T![if])?;
+    let expr = ast::IfExpr::cast(if_keyword.parent())?;
+    let if_range = if_keyword.text_range();
+    let cursor_in_range = ctx.frange.range.is_subrange(&if_range);
+    if !cursor_in_range {
+        return None;
+    }
+    let cond = expr.condition()?.expr()?;
+    let then_node = expr.then_branch()?.syntax().clone();
+    if let ast::ElseBranch::Block(else_block) = expr.else_branch()? {
+        let flip_cond = invert_boolean_expression(&cond)?;
+        let cond_range = cond.syntax().text_range();
+        let else_node = else_block.syntax();
+        let else_range = else_node.text_range();
+        let then_range = then_node.text_range();
+        return ctx.add_assist(AssistId("invert_if"), "invert if branches", |edit| {
+            edit.target(if_range);
+            edit.replace(cond_range, flip_cond.syntax().text());
+            edit.replace(else_range, then_node.text());
+            edit.replace(then_range, else_node.text());
+        });
+    }
+    None
+}
+pub(crate) fn invert_boolean_expression(expr: &ast::Expr) -> Option<ast::Expr> {
+    match expr {
+        ast::Expr::BinExpr(bin) => match bin.op_kind()? {
+            ast::BinOp::NegatedEqualityTest => bin.replace_op(T![==]).map(|it| it.into()),
+            _ => None,
+        },
+        ast::Expr::PrefixExpr(pe) => match pe.op_kind()? {
+            ast::PrefixOp::Not => pe.expr(),
+            _ => None,
+        },
+        _ => None,
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::helpers::{check_assist, check_assist_not_applicable};
+    #[test]
+    fn invert_if_remove_inequality() {
+        check_assist(
+            invert_if,
+            "fn f() { i<|>f x != 3 { 1 } else { 3 + 2 } }",
+            "fn f() { i<|>f x == 3 { 3 + 2 } else { 1 } }",
+        )
+    }
+    #[test]
+    fn invert_if_remove_not() {
+        check_assist(
+            invert_if,
+            "fn f() { <|>if !cond { 3 * 2 } else { 1 } }",
+            "fn f() { <|>if cond { 1 } else { 3 * 2 } }",
+        )
+    }
+    #[test]
+    fn invert_if_doesnt_apply_with_cursor_not_on_if() {
+        check_assist_not_applicable(invert_if, "fn f() { if !<|>cond { 3 * 2 } else { 1 } }")
+    }
+    #[test]
+    fn invert_if_doesnt_apply_without_negated() {
+        check_assist_not_applicable(invert_if, "fn f() { i<|>f cond { 3 * 2 } else { 1 } }")
+    }
+}
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index 176761efb..3c716c2d1 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -342,6 +342,23 @@ fn main() {
 }
 #[test]
+fn doctest_invert_if() {
+    check(
+        "invert_if",
+        r#####"
+fn main() {
+    if<|> !y { A } else { B }
+}
+"#####,
+        r#####"
+fn main() {
+    if y { B } else { A }
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_make_raw_string() {
    check(
        "make_raw_string",
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index f2f0dacbf..a372bd8b9 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -97,6 +97,7 @@ mod assists {
    mod add_impl;
    mod add_new;
    mod apply_demorgan;
+    mod invert_if;
    mod flip_comma;
    mod flip_binexpr;
    mod flip_trait_bound;
@@ -122,6 +123,7 @@ mod assists {
            add_impl::add_impl,
            add_new::add_new,
            apply_demorgan::apply_demorgan,
+            invert_if::invert_if,
            change_visibility::change_visibility,
            fill_match_arms::fill_match_arms,
            merge_match_arms::merge_match_arms,
diff --git a/crates/ra_assists/src/test_db.rs b/crates/ra_assists/src/test_db.rs
index 5be7383ed..5f96c974b 100644
--- a/crates/ra_assists/src/test_db.rs
+++ b/crates/ra_assists/src/test_db.rs
@@ -10,7 +10,6 @@ use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath
    hir::db::InternDatabaseStorage,
    hir::db::AstDatabaseStorage,
    hir::db::DefDatabaseStorage,
-    hir::db::DefDatabase2Storage,
    hir::db::HirDatabaseStorage
 )]
 #[derive(Debug, Default)]
diff --git a/crates/ra_batch/src/lib.rs b/crates/ra_batch/src/lib.rs
index df49eb13d..cb389eb26 100644
--- a/crates/ra_batch/src/lib.rs
+++ b/crates/ra_batch/src/lib.rs
@@ -117,9 +117,12 @@ pub fn load(
                        done = true;
                    }
                }
-                VfsChange::AddFile { .. }
+                VfsChange::AddFile { root, file, path, text } => {
-                | VfsChange::RemoveFile { .. }
+                    let source_root_id = vfs_root_to_id(root);
-                | VfsChange::ChangeFile { .. } => {
+                    let file_id = vfs_file_to_id(file);
+                    analysis_change.add_file(source_root_id, file_id, path, text);
+                }
+                VfsChange::RemoveFile { .. } | VfsChange::ChangeFile { .. } => {
                    // We just need the first scan, so just ignore these
                }
            }
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index 9cd21e4b6..c4eb28245 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -3,7 +3,7 @@
 use std::{collections::HashSet, fmt::Write, path::Path, time::Instant};
 use ra_db::SourceDatabaseExt;
-use ra_hir::{AssocItem, Crate, HasBodySource, HasSource, HirDisplay, ModuleDef, Ty, TypeWalk};
+use ra_hir::{AssocItem, Crate, HasSource, HirDisplay, ModuleDef, Ty, TypeWalk};
 use ra_syntax::AstNode;
 use crate::{Result, Verbosity};
@@ -109,7 +109,7 @@ pub fn run(
        }
        let body = f.body(db);
        let inference_result = f.infer(db);
-        for (expr_id, _) in body.exprs() {
+        for (expr_id, _) in body.exprs.iter() {
            let ty = &inference_result[expr_id];
            num_exprs += 1;
            if let Ty::Unknown = ty {
@@ -128,15 +128,16 @@ pub fn run(
            if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr_id) {
                num_type_mismatches += 1;
                if verbosity.is_verbose() {
-                    let src = f.expr_source(db, expr_id);
+                    let src = f.body_source_map(db).expr_syntax(expr_id);
                    if let Some(src) = src {
                        // FIXME: it might be nice to have a function (on Analysis?) that goes from Source<T> -> (LineCol, LineCol) directly
                        let original_file = src.file_id.original_file(db);
                        let path = db.file_relative_path(original_file);
                        let line_index = host.analysis().file_line_index(original_file).unwrap();
-                        let text_range = src
+                        let text_range = src.value.either(
-                            .value
+                            |it| it.syntax_node_ptr().range(),
-                            .either(|it| it.syntax().text_range(), |it| it.syntax().text_range());
+                            |it| it.syntax_node_ptr().range(),
+                        );
                        let (start, end) = (
                            line_index.line_col(text_range.start()),
                            line_index.line_col(text_range.end()),
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index ade187629..e8f335e33 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -8,7 +8,7 @@ use rustc_hash::FxHashMap;
 use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
 use crate::{
-    CrateGraph, CrateId, Edition, FileId, FilePosition, RelativePathBuf, SourceDatabaseExt,
+    CrateGraph, CrateId, Edition, Env, FileId, FilePosition, RelativePathBuf, SourceDatabaseExt,
    SourceRoot, SourceRootId,
 };
@@ -53,7 +53,12 @@ fn with_single_file(db: &mut dyn SourceDatabaseExt, text: &str) -> FileId {
    source_root.insert_file(rel_path.clone(), file_id);
    let mut crate_graph = CrateGraph::default();
-    crate_graph.add_crate_root(file_id, Edition::Edition2018, CfgOptions::default());
+    crate_graph.add_crate_root(
+        file_id,
+        Edition::Edition2018,
+        CfgOptions::default(),
+        Env::default(),
+    );
    db.set_file_text(file_id, Arc::new(text.to_string()));
    db.set_file_relative_path(file_id, rel_path);
@@ -93,7 +98,8 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
        assert!(meta.path.starts_with(&source_root_prefix));
        if let Some(krate) = meta.krate {
-            let crate_id = crate_graph.add_crate_root(file_id, meta.edition, meta.cfg);
+            let crate_id =
+                crate_graph.add_crate_root(file_id, meta.edition, meta.cfg, Env::default());
            let prev = crates.insert(krate.clone(), crate_id);
            assert!(prev.is_none());
            for dep in meta.deps {
@@ -123,7 +129,12 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
    if crates.is_empty() {
        let crate_root = default_crate_root.unwrap();
-        crate_graph.add_crate_root(crate_root, Edition::Edition2018, CfgOptions::default());
+        crate_graph.add_crate_root(
+            crate_root,
+            Edition::Edition2018,
+            CfgOptions::default(),
+            Env::default(),
+        );
    } else {
        for (from, to) in crate_deps {
            let from_id = crates[&from];
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index c0d95a13f..b6d851776 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -6,14 +6,14 @@
 //! actual IO. See `vfs` and `project_model` in the `ra_lsp_server` crate for how
 //! actual IO is done and lowered to input.
-use rustc_hash::FxHashMap;
+use std::{fmt, str::FromStr};
 use ra_cfg::CfgOptions;
 use ra_syntax::SmolStr;
+use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
 use crate::{RelativePath, RelativePathBuf};
-use std::str::FromStr;
 /// `FileId` is an integer which uniquely identifies a file. File paths are
 /// messy and system-dependent, so most of the code should work directly with
@@ -80,56 +80,27 @@ pub struct CrateGraph {
    arena: FxHashMap<CrateId, CrateData>,
 }
-#[derive(Debug)]
-pub struct CyclicDependencies;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct CrateId(pub u32);
-impl CrateId {
-    pub fn shift(self, amount: u32) -> CrateId {
-        CrateId(self.0 + amount)
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum Edition {
-    Edition2018,
-    Edition2015,
-}
-#[derive(Debug)]
-pub struct ParseEditionError {
-    pub msg: String,
-}
-impl FromStr for Edition {
-    type Err = ParseEditionError;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "2015" => Ok(Edition::Edition2015),
-            "2018" => Ok(Edition::Edition2018),
-            _ => Err(ParseEditionError { msg: format!("unknown edition: {}", s) }),
-        }
-    }
-}
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct CrateData {
    file_id: FileId,
    edition: Edition,
-    dependencies: Vec<Dependency>,
    cfg_options: CfgOptions,
+    env: Env,
+    dependencies: Vec<Dependency>,
 }
-impl CrateData {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-    fn new(file_id: FileId, edition: Edition, cfg_options: CfgOptions) -> CrateData {
+pub enum Edition {
-        CrateData { file_id, edition, dependencies: Vec::new(), cfg_options }
+    Edition2018,
-    }
+    Edition2015,
+}
-    fn add_dep(&mut self, name: SmolStr, crate_id: CrateId) {
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
-        self.dependencies.push(Dependency { name, crate_id })
+pub struct Env {
-    }
+    entries: FxHashMap<String, String>,
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -138,21 +109,17 @@ pub struct Dependency {
    pub name: SmolStr,
 }
-impl Dependency {
-    pub fn crate_id(&self) -> CrateId {
-        self.crate_id
-    }
-}
 impl CrateGraph {
    pub fn add_crate_root(
        &mut self,
        file_id: FileId,
        edition: Edition,
        cfg_options: CfgOptions,
+        env: Env,
    ) -> CrateId {
+        let data = CrateData::new(file_id, edition, cfg_options, env);
        let crate_id = CrateId(self.arena.len() as u32);
-        let prev = self.arena.insert(crate_id, CrateData::new(file_id, edition, cfg_options));
+        let prev = self.arena.insert(crate_id, data);
        assert!(prev.is_none());
        crate_id
    }
@@ -166,9 +133,9 @@ impl CrateGraph {
        from: CrateId,
        name: SmolStr,
        to: CrateId,
-    ) -> Result<(), CyclicDependencies> {
+    ) -> Result<(), CyclicDependenciesError> {
        if self.dfs_find(from, to, &mut FxHashSet::default()) {
-            return Err(CyclicDependencies);
+            return Err(CyclicDependenciesError);
        }
        self.arena.get_mut(&from).unwrap().add_dep(name, to);
        Ok(())
@@ -239,16 +206,70 @@ impl CrateGraph {
    }
 }
+impl CrateId {
+    pub fn shift(self, amount: u32) -> CrateId {
+        CrateId(self.0 + amount)
+    }
+}
+impl CrateData {
+    fn new(file_id: FileId, edition: Edition, cfg_options: CfgOptions, env: Env) -> CrateData {
+        CrateData { file_id, edition, dependencies: Vec::new(), cfg_options, env }
+    }
+    fn add_dep(&mut self, name: SmolStr, crate_id: CrateId) {
+        self.dependencies.push(Dependency { name, crate_id })
+    }
+}
+impl FromStr for Edition {
+    type Err = ParseEditionError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let res = match s {
+            "2015" => Edition::Edition2015,
+            "2018" => Edition::Edition2018,
+            _ => Err(ParseEditionError { invalid_input: s.to_string() })?,
+        };
+        Ok(res)
+    }
+}
+impl Dependency {
+    pub fn crate_id(&self) -> CrateId {
+        self.crate_id
+    }
+}
+#[derive(Debug)]
+pub struct ParseEditionError {
+    invalid_input: String,
+}
+impl fmt::Display for ParseEditionError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "invalid edition: {:?}", self.invalid_input)
+    }
+}
+impl std::error::Error for ParseEditionError {}
+#[derive(Debug)]
+pub struct CyclicDependenciesError;
 #[cfg(test)]
 mod tests {
-    use super::{CfgOptions, CrateGraph, Edition::Edition2018, FileId, SmolStr};
+    use super::{CfgOptions, CrateGraph, Edition::Edition2018, Env, FileId, SmolStr};
    #[test]
    fn it_should_panic_because_of_cycle_dependencies() {
        let mut graph = CrateGraph::default();
-        let crate1 = graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default());
+        let crate1 =
-        let crate2 = graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default());
+            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
-        let crate3 = graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default());
+        let crate2 =
+            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+        let crate3 =
+            graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default(), Env::default());
        assert!(graph.add_dep(crate1, SmolStr::new("crate2"), crate2).is_ok());
        assert!(graph.add_dep(crate2, SmolStr::new("crate3"), crate3).is_ok());
        assert!(graph.add_dep(crate3, SmolStr::new("crate1"), crate1).is_err());
@@ -257,9 +278,12 @@ mod tests {
    #[test]
    fn it_works() {
        let mut graph = CrateGraph::default();
-        let crate1 = graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default());
+        let crate1 =
-        let crate2 = graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default());
+            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
-        let crate3 = graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default());
+        let crate2 =
+            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+        let crate3 =
+            graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default(), Env::default());
        assert!(graph.add_dep(crate1, SmolStr::new("crate2"), crate2).is_ok());
        assert!(graph.add_dep(crate2, SmolStr::new("crate3"), crate3).is_ok());
    }
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index b6bfd531d..e8852531b 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -10,11 +10,25 @@ use ra_syntax::{ast, Parse, SourceFile, TextRange, TextUnit};
 pub use crate::{
    cancellation::Canceled,
-    input::{CrateGraph, CrateId, Dependency, Edition, FileId, SourceRoot, SourceRootId},
+    input::{CrateGraph, CrateId, Dependency, Edition, Env, FileId, SourceRoot, SourceRootId},
 };
 pub use relative_path::{RelativePath, RelativePathBuf};
 pub use salsa;
+#[macro_export]
+macro_rules! impl_intern_key {
+    ($name:ident) => {
+        impl $crate::salsa::InternKey for $name {
+            fn from_intern_id(v: $crate::salsa::InternId) -> Self {
+                $name(v)
+            }
+            fn as_intern_id(&self) -> $crate::salsa::InternId {
+                self.0
+            }
+        }
+    };
+}
 pub trait CheckCanceled {
    /// Aborts current query if there are pending changes.
    ///
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 5690040a7..3f44a50c4 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -1,38 +1,33 @@
 //! FIXME: write short doc here
 pub(crate) mod src;
-pub(crate) mod docs;
-pub(crate) mod attrs;
 use std::sync::Arc;
 use hir_def::{
    adt::VariantData,
-    body::scope::ExprScopes,
    builtin_type::BuiltinType,
-    nameres::per_ns::PerNs,
+    docs::Documentation,
+    per_ns::PerNs,
    resolver::{HasResolver, TypeNs},
-    traits::TraitData,
+    type_ref::TypeRef,
-    type_ref::{Mutability, TypeRef},
+    AstItemDef, ConstId, ContainerId, EnumId, FunctionId, HasModule, ImplId, LocalEnumVariantId,
-    ContainerId, CrateModuleId, HasModule, ImplId, LocalEnumVariantId, LocalStructFieldId, Lookup,
+    LocalImportId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId, StructId,
-    ModuleId, UnionId,
+    TraitId, TypeAliasId, UnionId,
 };
 use hir_expand::{
    diagnostics::DiagnosticSink,
    name::{self, AsName},
+    AstId, MacroDefId,
 };
-use ra_db::{CrateId, Edition};
+use ra_db::{CrateId, Edition, FileId, FilePosition};
-use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
+use ra_syntax::{ast, AstNode, SyntaxNode};
 use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
+    db::{DefDatabase, HirDatabase},
    expr::{BindingAnnotation, Body, BodySourceMap, ExprValidator, Pat, PatId},
-    ids::{
-        AstItemDef, ConstId, EnumId, FunctionId, MacroDefId, StaticId, StructId, TraitId,
-        TypeAliasId,
-    },
    ty::{InferenceResult, Namespace, TraitRef},
-    Either, HasSource, ImportId, Name, Source, Ty,
+    Either, Name, Source, Ty,
 };
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -66,7 +61,7 @@ impl Crate {
    }
    pub fn root_module(self, db: &impl DefDatabase) -> Option<Module> {
-        let module_id = db.crate_def_map(self.crate_id).root();
+        let module_id = db.crate_def_map(self.crate_id).root;
        Some(Module::new(self, module_id))
    }
@@ -80,6 +75,64 @@ impl Crate {
    }
 }
+pub enum ModuleSource {
+    SourceFile(ast::SourceFile),
+    Module(ast::Module),
+}
+impl ModuleSource {
+    pub fn new(
+        db: &impl DefDatabase,
+        file_id: Option<FileId>,
+        decl_id: Option<AstId<ast::Module>>,
+    ) -> ModuleSource {
+        match (file_id, decl_id) {
+            (Some(file_id), _) => {
+                let source_file = db.parse(file_id).tree();
+                ModuleSource::SourceFile(source_file)
+            }
+            (None, Some(item_id)) => {
+                let module = item_id.to_node(db);
+                assert!(module.item_list().is_some(), "expected inline module");
+                ModuleSource::Module(module)
+            }
+            (None, None) => panic!(),
+        }
+    }
+    // FIXME: this methods do not belong here
+    pub fn from_position(db: &impl DefDatabase, position: FilePosition) -> ModuleSource {
+        let parse = db.parse(position.file_id);
+        match &ra_syntax::algo::find_node_at_offset::<ast::Module>(
+            parse.tree().syntax(),
+            position.offset,
+        ) {
+            Some(m) if !m.has_semi() => ModuleSource::Module(m.clone()),
+            _ => {
+                let source_file = parse.tree();
+                ModuleSource::SourceFile(source_file)
+            }
+        }
+    }
+    pub fn from_child_node(db: &impl DefDatabase, child: Source<&SyntaxNode>) -> ModuleSource {
+        if let Some(m) =
+            child.value.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi())
+        {
+            ModuleSource::Module(m)
+        } else {
+            let file_id = child.file_id.original_file(db);
+            let source_file = db.parse(file_id).tree();
+            ModuleSource::SourceFile(source_file)
+        }
+    }
+    pub fn from_file_id(db: &impl DefDatabase, file_id: FileId) -> ModuleSource {
+        let source_file = db.parse(file_id).tree();
+        ModuleSource::SourceFile(source_file)
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Module {
    pub(crate) id: ModuleId,
@@ -111,10 +164,10 @@ impl_froms!(
    BuiltinType
 );
-pub use hir_def::ModuleSource;
+pub use hir_def::attr::Attrs;
 impl Module {
-    pub(crate) fn new(krate: Crate, crate_module_id: CrateModuleId) -> Module {
+    pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
        Module { id: ModuleId { krate: krate.crate_id, module_id: crate_module_id } }
    }
@@ -131,17 +184,6 @@ impl Module {
        })
    }
-    /// Returns the syntax of the last path segment corresponding to this import
-    pub fn import_source(
-        self,
-        db: &impl HirDatabase,
-        import: ImportId,
-    ) -> Either<ast::UseTree, ast::ExternCrateItem> {
-        let src = self.definition_source(db);
-        let (_, source_map) = db.raw_items_with_source_map(src.file_id);
-        source_map.get(&src.value, import)
-    }
    /// Returns the crate this module is part of.
    pub fn krate(self) -> Crate {
        Crate { crate_id: self.id.krate }
@@ -152,7 +194,7 @@ impl Module {
    /// in the module tree of any target in `Cargo.toml`.
    pub fn crate_root(self, db: &impl DefDatabase) -> Module {
        let def_map = db.crate_def_map(self.id.krate);
-        self.with_module_id(def_map.root())
+        self.with_module_id(def_map.root)
    }
    /// Finds a child module with the specified name.
@@ -191,11 +233,13 @@ impl Module {
    }
    /// Returns a `ModuleScope`: a set of items, visible in this module.
-    pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef, Option<ImportId>)> {
+    pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef, Option<Import>)> {
        db.crate_def_map(self.id.krate)[self.id.module_id]
            .scope
            .entries()
-            .map(|(name, res)| (name.clone(), res.def.into(), res.import))
+            .map(|(name, res)| {
+                (name.clone(), res.def.into(), res.import.map(|id| Import { parent: self, id }))
+            })
            .collect()
    }
@@ -233,11 +277,16 @@ impl Module {
        def_map[self.id.module_id].impls.iter().copied().map(ImplBlock::from).collect()
    }
-    fn with_module_id(self, module_id: CrateModuleId) -> Module {
+    fn with_module_id(self, module_id: LocalModuleId) -> Module {
        Module::new(self.krate(), module_id)
    }
 }
+pub struct Import {
+    pub(crate) parent: Module,
+    pub(crate) id: LocalImportId,
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct StructField {
    pub(crate) parent: VariantDef,
@@ -252,11 +301,11 @@ pub enum FieldSource {
 impl StructField {
    pub fn name(&self, db: &impl HirDatabase) -> Name {
-        self.parent.variant_data(db).fields().unwrap()[self.id].name.clone()
+        self.parent.variant_data(db).fields()[self.id].name.clone()
    }
    pub fn ty(&self, db: &impl HirDatabase) -> Ty {
-        db.type_for_field(*self)
+        db.field_types(self.parent.into())[self.id].clone()
    }
    pub fn parent_def(&self, _db: &impl HirDatabase) -> VariantDef {
@@ -286,8 +335,7 @@ impl Struct {
        db.struct_data(self.id.into())
            .variant_data
            .fields()
-            .into_iter()
+            .iter()
-            .flat_map(|it| it.iter())
            .map(|(id, _)| StructField { parent: self.into(), id })
            .collect()
    }
@@ -296,8 +344,7 @@ impl Struct {
        db.struct_data(self.id.into())
            .variant_data
            .fields()
-            .into_iter()
+            .iter()
-            .flat_map(|it| it.iter())
            .find(|(_id, data)| data.name == *name)
            .map(|(id, _)| StructField { parent: self.into(), id })
    }
@@ -394,8 +441,7 @@ impl EnumVariant {
    pub fn fields(self, db: &impl HirDatabase) -> Vec<StructField> {
        self.variant_data(db)
            .fields()
-            .into_iter()
+            .iter()
-            .flat_map(|it| it.iter())
            .map(|(id, _)| StructField { parent: self.into(), id })
            .collect()
    }
@@ -403,8 +449,7 @@ impl EnumVariant {
    pub fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
        self.variant_data(db)
            .fields()
-            .into_iter()
+            .iter()
-            .flat_map(|it| it.iter())
            .find(|(_id, data)| data.name == *name)
            .map(|(id, _)| StructField { parent: self.into(), id })
    }
@@ -460,7 +505,7 @@ impl VariantDef {
        }
    }
-    pub fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
+    pub(crate) fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
        match self {
            VariantDef::Struct(it) => it.field(db, name),
            VariantDef::EnumVariant(it) => it.field(db, name),
@@ -510,128 +555,11 @@ impl DefWithBody {
    }
 }
-pub trait HasBody: Copy {
-    fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult>;
-    fn body(self, db: &impl HirDatabase) -> Arc<Body>;
-    fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap>;
-    fn expr_scopes(self, db: &impl HirDatabase) -> Arc<ExprScopes>;
-}
-impl<T> HasBody for T
-where
-    T: Into<DefWithBody> + Copy + HasSource,
-{
-    fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
-        db.infer(self.into())
-    }
-    fn body(self, db: &impl HirDatabase) -> Arc<Body> {
-        self.into().body(db)
-    }
-    fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
-        self.into().body_source_map(db)
-    }
-    fn expr_scopes(self, db: &impl HirDatabase) -> Arc<ExprScopes> {
-        self.into().expr_scopes(db)
-    }
-}
-impl HasBody for DefWithBody {
-    fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
-        db.infer(self)
-    }
-    fn body(self, db: &impl HirDatabase) -> Arc<Body> {
-        db.body(self.into())
-    }
-    fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
-        db.body_with_source_map(self.into()).1
-    }
-    fn expr_scopes(self, db: &impl HirDatabase) -> Arc<ExprScopes> {
-        db.expr_scopes(self.into())
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Function {
    pub(crate) id: FunctionId,
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct FnData {
-    pub(crate) name: Name,
-    pub(crate) params: Vec<TypeRef>,
-    pub(crate) ret_type: TypeRef,
-    /// True if the first param is `self`. This is relevant to decide whether this
-    /// can be called as a method.
-    pub(crate) has_self_param: bool,
-}
-impl FnData {
-    pub(crate) fn fn_data_query(
-        db: &(impl DefDatabase + AstDatabase),
-        func: Function,
-    ) -> Arc<FnData> {
-        let src = func.source(db);
-        let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
-        let mut params = Vec::new();
-        let mut has_self_param = false;
-        if let Some(param_list) = src.value.param_list() {
-            if let Some(self_param) = param_list.self_param() {
-                let self_type = if let Some(type_ref) = self_param.ascribed_type() {
-                    TypeRef::from_ast(type_ref)
-                } else {
-                    let self_type = TypeRef::Path(name::SELF_TYPE.into());
-                    match self_param.kind() {
-                        ast::SelfParamKind::Owned => self_type,
-                        ast::SelfParamKind::Ref => {
-                            TypeRef::Reference(Box::new(self_type), Mutability::Shared)
-                        }
-                        ast::SelfParamKind::MutRef => {
-                            TypeRef::Reference(Box::new(self_type), Mutability::Mut)
-                        }
-                    }
-                };
-                params.push(self_type);
-                has_self_param = true;
-            }
-            for param in param_list.params() {
-                let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
-                params.push(type_ref);
-            }
-        }
-        let ret_type = if let Some(type_ref) = src.value.ret_type().and_then(|rt| rt.type_ref()) {
-            TypeRef::from_ast(type_ref)
-        } else {
-            TypeRef::unit()
-        };
-        let sig = FnData { name, params, ret_type, has_self_param };
-        Arc::new(sig)
-    }
-    pub fn name(&self) -> &Name {
-        &self.name
-    }
-    pub fn params(&self) -> &[TypeRef] {
-        &self.params
-    }
-    pub fn ret_type(&self) -> &TypeRef {
-        &self.ret_type
-    }
-    /// True if the first arg is `self`. This is relevant to decide whether this
-    /// can be called as a method.
-    pub fn has_self_param(&self) -> bool {
-        self.has_self_param
-    }
-}
 impl Function {
    pub fn module(self, db: &impl DefDatabase) -> Module {
        self.id.lookup(db).module(db).into()
@@ -642,10 +570,18 @@ impl Function {
    }
    pub fn name(self, db: &impl HirDatabase) -> Name {
-        self.data(db).name.clone()
+        db.function_data(self.id).name.clone()
+    }
+    pub fn has_self_param(self, db: &impl HirDatabase) -> bool {
+        db.function_data(self.id).has_self_param
+    }
+    pub fn params(self, db: &impl HirDatabase) -> Vec<TypeRef> {
+        db.function_data(self.id).params.clone()
    }
-    pub(crate) fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
+    pub fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
        db.body_with_source_map(self.id.into()).1
    }
@@ -657,10 +593,6 @@ impl Function {
        db.type_for_def(self.into(), Namespace::Values)
    }
-    pub fn data(self, db: &impl HirDatabase) -> Arc<FnData> {
-        db.fn_data(self)
-    }
    pub fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
        db.infer(self.into())
    }
@@ -711,12 +643,8 @@ impl Const {
        Some(self.module(db).krate())
    }
-    pub fn data(self, db: &impl HirDatabase) -> Arc<ConstData> {
-        db.const_data(self)
-    }
    pub fn name(self, db: &impl HirDatabase) -> Option<Name> {
-        self.data(db).name().cloned()
+        db.const_data(self.id).name.clone()
    }
    pub fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
@@ -748,45 +676,6 @@ impl Const {
    }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ConstData {
-    pub(crate) name: Option<Name>,
-    pub(crate) type_ref: TypeRef,
-}
-impl ConstData {
-    pub fn name(&self) -> Option<&Name> {
-        self.name.as_ref()
-    }
-    pub fn type_ref(&self) -> &TypeRef {
-        &self.type_ref
-    }
-    pub(crate) fn const_data_query(
-        db: &(impl DefDatabase + AstDatabase),
-        konst: Const,
-    ) -> Arc<ConstData> {
-        let node = konst.source(db).value;
-        const_data_for(&node)
-    }
-    pub(crate) fn static_data_query(
-        db: &(impl DefDatabase + AstDatabase),
-        konst: Static,
-    ) -> Arc<ConstData> {
-        let node = konst.source(db).value;
-        const_data_for(&node)
-    }
-}
-fn const_data_for<N: NameOwner + TypeAscriptionOwner>(node: &N) -> Arc<ConstData> {
-    let name = node.name().map(|n| n.as_name());
-    let type_ref = TypeRef::from_ast_opt(node.ascribed_type());
-    let sig = ConstData { name, type_ref };
-    Arc::new(sig)
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Static {
    pub(crate) id: StaticId,
@@ -794,17 +683,13 @@ pub struct Static {
 impl Static {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        Module { id: self.id.module(db) }
+        Module { id: self.id.lookup(db).module(db) }
    }
    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
        Some(self.module(db).krate())
    }
-    pub fn data(self, db: &impl HirDatabase) -> Arc<ConstData> {
-        db.static_data(self)
-    }
    pub fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
        db.infer(self.into())
    }
@@ -821,11 +706,11 @@ impl Trait {
    }
    pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
-        self.trait_data(db).name.clone()
+        db.trait_data(self.id).name.clone()
    }
    pub fn items(self, db: &impl DefDatabase) -> Vec<AssocItem> {
-        self.trait_data(db).items.iter().map(|it| (*it).into()).collect()
+        db.trait_data(self.id).items.iter().map(|it| (*it).into()).collect()
    }
    fn direct_super_traits(self, db: &impl HirDatabase) -> Vec<Trait> {
@@ -871,7 +756,7 @@ impl Trait {
    }
    pub fn associated_type_by_name(self, db: &impl DefDatabase, name: &Name) -> Option<TypeAlias> {
-        let trait_data = self.trait_data(db);
+        let trait_data = db.trait_data(self.id);
        let res =
            trait_data.associated_types().map(TypeAlias::from).find(|t| &t.name(db) == name)?;
        Some(res)
@@ -885,16 +770,12 @@ impl Trait {
        self.all_super_traits(db).into_iter().find_map(|t| t.associated_type_by_name(db, name))
    }
-    pub(crate) fn trait_data(self, db: &impl DefDatabase) -> Arc<TraitData> {
-        db.trait_data(self.id)
-    }
    pub fn trait_ref(self, db: &impl HirDatabase) -> TraitRef {
        TraitRef::for_trait(db, self)
    }
    pub fn is_auto(self, db: &impl DefDatabase) -> bool {
-        self.trait_data(db).auto
+        db.trait_data(self.id).auto
    }
 }
@@ -937,7 +818,7 @@ impl TypeAlias {
    }
    pub fn type_ref(self, db: &impl DefDatabase) -> Option<TypeRef> {
-        db.type_alias_data(self).type_ref.clone()
+        db.type_alias_data(self.id).type_ref.clone()
    }
    pub fn ty(self, db: &impl HirDatabase) -> Ty {
@@ -945,7 +826,7 @@ impl TypeAlias {
    }
    pub fn name(self, db: &impl DefDatabase) -> Name {
-        db.type_alias_data(self).name.clone()
+        db.type_alias_data(self.id).name.clone()
    }
 }
@@ -1034,7 +915,7 @@ pub struct Local {
 impl Local {
    pub fn name(self, db: &impl HirDatabase) -> Option<Name> {
-        let body = self.parent.body(db);
+        let body = db.body(self.parent.into());
        match &body[self.pat_id] {
            Pat::Bind { name, .. } => Some(name.clone()),
            _ => None,
@@ -1046,7 +927,7 @@ impl Local {
    }
    pub fn is_mut(self, db: &impl HirDatabase) -> bool {
-        let body = self.parent.body(db);
+        let body = db.body(self.parent.into());
        match &body[self.pat_id] {
            Pat::Bind { mode, .. } => match mode {
                BindingAnnotation::Mutable | BindingAnnotation::RefMut => true,
@@ -1070,7 +951,7 @@ impl Local {
    }
    pub fn source(self, db: &impl HirDatabase) -> Source<Either<ast::BindPat, ast::SelfParam>> {
-        let source_map = self.parent.body_source_map(db);
+        let (_body, source_map) = db.body_with_source_map(self.parent.into());
        let src = source_map.pat_syntax(self.pat_id).unwrap(); // Hmm...
        let root = src.file_syntax(db);
        src.map(|ast| ast.map(|it| it.cast().unwrap().to_node(&root), |it| it.to_node(&root)))
@@ -1088,6 +969,41 @@ pub struct ImplBlock {
    pub(crate) id: ImplId,
 }
+impl ImplBlock {
+    pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
+        db.impl_data(self.id).target_trait.clone()
+    }
+    pub fn target_type(&self, db: &impl DefDatabase) -> TypeRef {
+        db.impl_data(self.id).target_type.clone()
+    }
+    pub fn target_ty(&self, db: &impl HirDatabase) -> Ty {
+        Ty::from_hir(db, &self.id.resolver(db), &self.target_type(db))
+    }
+    pub fn target_trait_ref(&self, db: &impl HirDatabase) -> Option<TraitRef> {
+        let target_ty = self.target_ty(db);
+        TraitRef::from_hir(db, &self.id.resolver(db), &self.target_trait(db)?, Some(target_ty))
+    }
+    pub fn items(&self, db: &impl DefDatabase) -> Vec<AssocItem> {
+        db.impl_data(self.id).items.iter().map(|it| (*it).into()).collect()
+    }
+    pub fn is_negative(&self, db: &impl DefDatabase) -> bool {
+        db.impl_data(self.id).is_negative
+    }
+    pub fn module(&self, db: &impl DefDatabase) -> Module {
+        self.id.module(db).into()
+    }
+    pub fn krate(&self, db: &impl DefDatabase) -> Crate {
+        Crate { crate_id: self.module(db).id.krate }
+    }
+}
 /// For IDE only
 pub enum ScopeDef {
    ModuleDef(ModuleDef),
@@ -1105,8 +1021,56 @@ impl From<PerNs> for ScopeDef {
            .or_else(|| def.take_values())
            .map(|module_def_id| ScopeDef::ModuleDef(module_def_id.into()))
            .or_else(|| {
-                def.get_macros().map(|macro_def_id| ScopeDef::MacroDef(macro_def_id.into()))
+                def.take_macros().map(|macro_def_id| ScopeDef::MacroDef(macro_def_id.into()))
            })
            .unwrap_or(ScopeDef::Unknown)
    }
 }
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum AttrDef {
+    Module(Module),
+    StructField(StructField),
+    Adt(Adt),
+    Function(Function),
+    EnumVariant(EnumVariant),
+    Static(Static),
+    Const(Const),
+    Trait(Trait),
+    TypeAlias(TypeAlias),
+    MacroDef(MacroDef),
+}
+impl_froms!(
+    AttrDef: Module,
+    StructField,
+    Adt(Struct, Enum, Union),
+    EnumVariant,
+    Static,
+    Const,
+    Function,
+    Trait,
+    TypeAlias,
+    MacroDef
+);
+pub trait HasAttrs {
+    fn attrs(self, db: &impl DefDatabase) -> Attrs;
+}
+impl<T: Into<AttrDef>> HasAttrs for T {
+    fn attrs(self, db: &impl DefDatabase) -> Attrs {
+        let def: AttrDef = self.into();
+        db.attrs(def.into())
+    }
+}
+pub trait Docs {
+    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation>;
+}
+impl<T: Into<AttrDef> + Copy> Docs for T {
+    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
+        let def: AttrDef = (*self).into();
+        db.documentation(def.into())
+    }
+}
diff --git a/crates/ra_hir/src/code_model/attrs.rs b/crates/ra_hir/src/code_model/attrs.rs
deleted file mode 100644
index 9e304217c..000000000
--- a/crates/ra_hir/src/code_model/attrs.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-//! FIXME: write short doc here
-use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
-    Adt, Const, Enum, EnumVariant, FieldSource, Function, HasSource, MacroDef, Module, Static,
-    Struct, StructField, Trait, TypeAlias, Union,
-};
-use hir_def::attr::Attr;
-use hir_expand::hygiene::Hygiene;
-use ra_syntax::ast;
-use std::sync::Arc;
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum AttrDef {
-    Module(Module),
-    StructField(StructField),
-    Adt(Adt),
-    Function(Function),
-    EnumVariant(EnumVariant),
-    Static(Static),
-    Const(Const),
-    Trait(Trait),
-    TypeAlias(TypeAlias),
-    MacroDef(MacroDef),
-}
-impl_froms!(
-    AttrDef: Module,
-    StructField,
-    Adt(Struct, Enum, Union),
-    EnumVariant,
-    Static,
-    Const,
-    Function,
-    Trait,
-    TypeAlias,
-    MacroDef
-);
-pub trait Attrs {
-    fn attrs(&self, db: &impl HirDatabase) -> Option<Arc<[Attr]>>;
-}
-pub(crate) fn attributes_query(
-    db: &(impl DefDatabase + AstDatabase),
-    def: AttrDef,
-) -> Option<Arc<[Attr]>> {
-    match def {
-        AttrDef::Module(it) => {
-            let src = it.declaration_source(db)?;
-            let hygiene = Hygiene::new(db, src.file_id);
-            Attr::from_attrs_owner(&src.value, &hygiene)
-        }
-        AttrDef::StructField(it) => match it.source(db).value {
-            FieldSource::Named(named) => {
-                let src = it.source(db);
-                let hygiene = Hygiene::new(db, src.file_id);
-                Attr::from_attrs_owner(&named, &hygiene)
-            }
-            FieldSource::Pos(..) => None,
-        },
-        AttrDef::Adt(it) => match it {
-            Adt::Struct(it) => attrs_from_ast(it, db),
-            Adt::Enum(it) => attrs_from_ast(it, db),
-            Adt::Union(it) => attrs_from_ast(it, db),
-        },
-        AttrDef::EnumVariant(it) => attrs_from_ast(it, db),
-        AttrDef::Static(it) => attrs_from_ast(it, db),
-        AttrDef::Const(it) => attrs_from_ast(it, db),
-        AttrDef::Function(it) => attrs_from_ast(it, db),
-        AttrDef::Trait(it) => attrs_from_ast(it, db),
-        AttrDef::TypeAlias(it) => attrs_from_ast(it, db),
-        AttrDef::MacroDef(it) => attrs_from_ast(it, db),
-    }
-}
-fn attrs_from_ast<T, D>(node: T, db: &D) -> Option<Arc<[Attr]>>
-where
-    T: HasSource,
-    T::Ast: ast::AttrsOwner,
-    D: DefDatabase + AstDatabase,
-{
-    let src = node.source(db);
-    let hygiene = Hygiene::new(db, src.file_id);
-    Attr::from_attrs_owner(&src.value, &hygiene)
-}
-impl<T: Into<AttrDef> + Copy> Attrs for T {
-    fn attrs(&self, db: &impl HirDatabase) -> Option<Arc<[Attr]>> {
-        db.attrs((*self).into())
-    }
-}
diff --git a/crates/ra_hir/src/code_model/docs.rs b/crates/ra_hir/src/code_model/docs.rs
deleted file mode 100644
index e40efef34..000000000
--- a/crates/ra_hir/src/code_model/docs.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-//! FIXME: write short doc here
-use std::sync::Arc;
-use ra_syntax::ast;
-use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
-    Adt, Const, Enum, EnumVariant, FieldSource, Function, HasSource, MacroDef, Module, Static,
-    Struct, StructField, Trait, TypeAlias, Union,
-};
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum DocDef {
-    Module(Module),
-    StructField(StructField),
-    Adt(Adt),
-    EnumVariant(EnumVariant),
-    Static(Static),
-    Const(Const),
-    Function(Function),
-    Trait(Trait),
-    TypeAlias(TypeAlias),
-    MacroDef(MacroDef),
-}
-impl_froms!(
-    DocDef: Module,
-    StructField,
-    Adt(Struct, Enum, Union),
-    EnumVariant,
-    Static,
-    Const,
-    Function,
-    Trait,
-    TypeAlias,
-    MacroDef
-);
-/// Holds documentation
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Documentation(Arc<str>);
-impl Documentation {
-    fn new(s: &str) -> Documentation {
-        Documentation(s.into())
-    }
-    pub fn as_str(&self) -> &str {
-        &*self.0
-    }
-}
-impl Into<String> for Documentation {
-    fn into(self) -> String {
-        self.as_str().to_owned()
-    }
-}
-pub trait Docs {
-    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation>;
-}
-pub(crate) fn docs_from_ast(node: &impl ast::DocCommentsOwner) -> Option<Documentation> {
-    node.doc_comment_text().map(|it| Documentation::new(&it))
-}
-pub(crate) fn documentation_query(
-    db: &(impl DefDatabase + AstDatabase),
-    def: DocDef,
-) -> Option<Documentation> {
-    match def {
-        DocDef::Module(it) => docs_from_ast(&it.declaration_source(db)?.value),
-        DocDef::StructField(it) => match it.source(db).value {
-            FieldSource::Named(named) => docs_from_ast(&named),
-            FieldSource::Pos(..) => None,
-        },
-        DocDef::Adt(it) => match it {
-            Adt::Struct(it) => docs_from_ast(&it.source(db).value),
-            Adt::Enum(it) => docs_from_ast(&it.source(db).value),
-            Adt::Union(it) => docs_from_ast(&it.source(db).value),
-        },
-        DocDef::EnumVariant(it) => docs_from_ast(&it.source(db).value),
-        DocDef::Static(it) => docs_from_ast(&it.source(db).value),
-        DocDef::Const(it) => docs_from_ast(&it.source(db).value),
-        DocDef::Function(it) => docs_from_ast(&it.source(db).value),
-        DocDef::Trait(it) => docs_from_ast(&it.source(db).value),
-        DocDef::TypeAlias(it) => docs_from_ast(&it.source(db).value),
-        DocDef::MacroDef(it) => docs_from_ast(&it.source(db).value),
-    }
-}
-impl<T: Into<DocDef> + Copy> Docs for T {
-    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
-        db.documentation((*self).into())
-    }
-}
diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs
index 4aa427de4..a4e317c20 100644
--- a/crates/ra_hir/src/code_model/src.rs
+++ b/crates/ra_hir/src/code_model/src.rs
@@ -1,172 +1,128 @@
 //! FIXME: write short doc here
-use hir_def::{HasSource as _, Lookup};
+use hir_def::{AstItemDef, HasChildSource, HasSource as _, Lookup, VariantId};
-use ra_syntax::ast::{self, AstNode};
+use hir_expand::either::Either;
+use ra_syntax::ast;
 use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
+    db::DefDatabase, Const, Enum, EnumVariant, FieldSource, Function, ImplBlock, Import, MacroDef,
-    ids::AstItemDef,
+    Module, ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union,
-    Const, Either, Enum, EnumVariant, FieldSource, Function, HasBody, HirFileId, MacroDef, Module,
-    ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union, VariantDef,
 };
 pub use hir_expand::Source;
 pub trait HasSource {
    type Ast;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<Self::Ast>;
+    fn source(self, db: &impl DefDatabase) -> Source<Self::Ast>;
 }
 /// NB: Module is !HasSource, because it has two source nodes at the same time:
 /// definition and declaration.
 impl Module {
    /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
-    pub fn definition_source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ModuleSource> {
+    pub fn definition_source(self, db: &impl DefDatabase) -> Source<ModuleSource> {
        let def_map = db.crate_def_map(self.id.krate);
-        let decl_id = def_map[self.id.module_id].declaration;
+        let src = def_map[self.id.module_id].definition_source(db);
-        let file_id = def_map[self.id.module_id].definition;
+        src.map(|it| match it {
-        let value = ModuleSource::new(db, file_id, decl_id);
+            Either::A(it) => ModuleSource::SourceFile(it),
-        let file_id = file_id.map(HirFileId::from).unwrap_or_else(|| decl_id.unwrap().file_id());
+            Either::B(it) => ModuleSource::Module(it),
-        Source { file_id, value }
+        })
    }
    /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
    /// `None` for the crate root.
-    pub fn declaration_source(
+    pub fn declaration_source(self, db: &impl DefDatabase) -> Option<Source<ast::Module>> {
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> Option<Source<ast::Module>> {
        let def_map = db.crate_def_map(self.id.krate);
-        let decl = def_map[self.id.module_id].declaration?;
+        def_map[self.id.module_id].declaration_source(db)
-        let value = decl.to_node(db);
-        Some(Source { file_id: decl.file_id(), value })
    }
 }
 impl HasSource for StructField {
    type Ast = FieldSource;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<FieldSource> {
+    fn source(self, db: &impl DefDatabase) -> Source<FieldSource> {
-        let var_data = self.parent.variant_data(db);
+        let var = VariantId::from(self.parent);
-        let fields = var_data.fields().unwrap();
+        let src = var.child_source(db);
-        let ss;
+        src.map(|it| match it[self.id].clone() {
-        let es;
+            Either::A(it) => FieldSource::Pos(it),
-        let (file_id, struct_kind) = match self.parent {
+            Either::B(it) => FieldSource::Named(it),
-            VariantDef::Struct(s) => {
+        })
-                ss = s.source(db);
-                (ss.file_id, ss.value.kind())
-            }
-            VariantDef::EnumVariant(e) => {
-                es = e.source(db);
-                (es.file_id, es.value.kind())
-            }
-        };
-        let field_sources = match struct_kind {
-            ast::StructKind::Tuple(fl) => fl.fields().map(|it| FieldSource::Pos(it)).collect(),
-            ast::StructKind::Named(fl) => fl.fields().map(|it| FieldSource::Named(it)).collect(),
-            ast::StructKind::Unit => Vec::new(),
-        };
-        let value = field_sources
-            .into_iter()
-            .zip(fields.iter())
-            .find(|(_syntax, (id, _))| *id == self.id)
-            .unwrap()
-            .0;
-        Source { file_id, value }
    }
 }
 impl HasSource for Struct {
    type Ast = ast::StructDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::StructDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::StructDef> {
        self.id.0.source(db)
    }
 }
 impl HasSource for Union {
    type Ast = ast::StructDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::StructDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::StructDef> {
        self.id.0.source(db)
    }
 }
 impl HasSource for Enum {
    type Ast = ast::EnumDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::EnumDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::EnumDef> {
        self.id.source(db)
    }
 }
 impl HasSource for EnumVariant {
    type Ast = ast::EnumVariant;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::EnumVariant> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::EnumVariant> {
-        let enum_data = db.enum_data(self.parent.id);
+        self.parent.id.child_source(db).map(|map| map[self.id].clone())
-        let src = self.parent.id.source(db);
-        let value = src
-            .value
-            .variant_list()
-            .into_iter()
-            .flat_map(|it| it.variants())
-            .zip(enum_data.variants.iter())
-            .find(|(_syntax, (id, _))| *id == self.id)
-            .unwrap()
-            .0;
-        Source { file_id: src.file_id, value }
    }
 }
 impl HasSource for Function {
    type Ast = ast::FnDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::FnDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::FnDef> {
        self.id.lookup(db).source(db)
    }
 }
 impl HasSource for Const {
    type Ast = ast::ConstDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::ConstDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::ConstDef> {
        self.id.lookup(db).source(db)
    }
 }
 impl HasSource for Static {
    type Ast = ast::StaticDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::StaticDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::StaticDef> {
-        self.id.source(db)
+        self.id.lookup(db).source(db)
    }
 }
 impl HasSource for Trait {
    type Ast = ast::TraitDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::TraitDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::TraitDef> {
        self.id.source(db)
    }
 }
 impl HasSource for TypeAlias {
    type Ast = ast::TypeAliasDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::TypeAliasDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::TypeAliasDef> {
        self.id.lookup(db).source(db)
    }
 }
 impl HasSource for MacroDef {
    type Ast = ast::MacroCall;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::MacroCall> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::MacroCall> {
        Source { file_id: self.id.ast_id.file_id(), value: self.id.ast_id.to_node(db) }
    }
 }
+impl HasSource for ImplBlock {
-pub trait HasBodySource: HasBody + HasSource
+    type Ast = ast::ImplBlock;
-where
+    fn source(self, db: &impl DefDatabase) -> Source<ast::ImplBlock> {
-    Self::Ast: AstNode,
+        self.id.source(db)
-{
-    fn expr_source(
-        self,
-        db: &impl HirDatabase,
-        expr_id: crate::expr::ExprId,
-    ) -> Option<Source<Either<ast::Expr, ast::RecordField>>> {
-        let source_map = self.body_source_map(db);
-        let source_ptr = source_map.expr_syntax(expr_id)?;
-        let root = source_ptr.file_syntax(db);
-        let source = source_ptr.map(|ast| ast.map(|it| it.to_node(&root), |it| it.to_node(&root)));
-        Some(source)
    }
 }
+impl HasSource for Import {
+    type Ast = Either<ast::UseTree, ast::ExternCrateItem>;
-impl<T> HasBodySource for T
+    /// Returns the syntax of the last path segment corresponding to this import
-where
+    fn source(self, db: &impl DefDatabase) -> Source<Self::Ast> {
-    T: HasBody + HasSource,
+        let src = self.parent.definition_source(db);
-    T::Ast: AstNode,
+        let (_, source_map) = db.raw_items_with_source_map(src.file_id);
-{
+        let root = db.parse_or_expand(src.file_id).unwrap();
+        let ptr = source_map.get(self.id);
+        src.with_value(ptr.map(|it| it.to_node(&root), |it| it.to_node(&root)))
+    }
 }
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index ed0d68001..5084bbacf 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -2,79 +2,46 @@
 use std::sync::Arc;
-use hir_def::attr::Attr;
+use ra_arena::map::ArenaMap;
 use ra_db::salsa;
-use ra_syntax::SmolStr;
 use crate::{
-    debug::HirDebugDatabase,
-    ids,
-    lang_item::{LangItemTarget, LangItems},
    ty::{
        method_resolution::CrateImplBlocks,
        traits::{AssocTyValue, Impl},
        CallableDef, FnSig, GenericPredicate, InferenceResult, Namespace, Substs, Ty, TypableDef,
        TypeCtor,
    },
-    type_alias::TypeAliasData,
+    Crate, DefWithBody, GenericDef, ImplBlock, Trait,
-    Const, ConstData, Crate, DefWithBody, FnData, Function, GenericDef, ImplBlock, Module, Static,
-    StructField, Trait, TypeAlias,
 };
-pub use hir_def::db::{
+pub use hir_def::{
-    BodyQuery, BodyWithSourceMapQuery, CrateDefMapQuery, DefDatabase2, DefDatabase2Storage,
+    db::{
-    EnumDataQuery, ExprScopesQuery, GenericParamsQuery, ImplDataQuery, InternDatabase,
+        BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQuery, CrateLangItemsQuery,
-    InternDatabaseStorage, RawItemsQuery, RawItemsWithSourceMapQuery, StructDataQuery,
+        DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery, ExprScopesQuery,
-    TraitDataQuery,
+        FunctionDataQuery, GenericParamsQuery, ImplDataQuery, InternDatabase,
+        InternDatabaseStorage, LangItemQuery, ModuleLangItemsQuery, RawItemsQuery,
+        RawItemsWithSourceMapQuery, StaticDataQuery, StructDataQuery, TraitDataQuery,
+        TypeAliasDataQuery,
+    },
+    LocalStructFieldId, VariantId,
 };
 pub use hir_expand::db::{
    AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
    ParseMacroQuery,
 };
-// This database uses `AstDatabase` internally,
-#[salsa::query_group(DefDatabaseStorage)]
-#[salsa::requires(AstDatabase)]
-pub trait DefDatabase: HirDebugDatabase + DefDatabase2 {
-    #[salsa::invoke(FnData::fn_data_query)]
-    fn fn_data(&self, func: Function) -> Arc<FnData>;
-    #[salsa::invoke(TypeAliasData::type_alias_data_query)]
-    fn type_alias_data(&self, typ: TypeAlias) -> Arc<TypeAliasData>;
-    #[salsa::invoke(ConstData::const_data_query)]
-    fn const_data(&self, konst: Const) -> Arc<ConstData>;
-    #[salsa::invoke(ConstData::static_data_query)]
-    fn static_data(&self, konst: Static) -> Arc<ConstData>;
-    #[salsa::invoke(LangItems::module_lang_items_query)]
-    fn module_lang_items(&self, module: Module) -> Option<Arc<LangItems>>;
-    #[salsa::invoke(LangItems::crate_lang_items_query)]
-    fn crate_lang_items(&self, krate: Crate) -> Arc<LangItems>;
-    #[salsa::invoke(LangItems::lang_item_query)]
-    fn lang_item(&self, start_crate: Crate, item: SmolStr) -> Option<LangItemTarget>;
-    #[salsa::invoke(crate::code_model::docs::documentation_query)]
-    fn documentation(&self, def: crate::DocDef) -> Option<crate::Documentation>;
-    #[salsa::invoke(crate::code_model::attrs::attributes_query)]
-    fn attrs(&self, def: crate::AttrDef) -> Option<Arc<[Attr]>>;
-}
 #[salsa::query_group(HirDatabaseStorage)]
 #[salsa::requires(salsa::Database)]
-pub trait HirDatabase: DefDatabase + AstDatabase {
+pub trait HirDatabase: DefDatabase {
    #[salsa::invoke(crate::ty::infer_query)]
    fn infer(&self, def: DefWithBody) -> Arc<InferenceResult>;
    #[salsa::invoke(crate::ty::type_for_def)]
    fn type_for_def(&self, def: TypableDef, ns: Namespace) -> Ty;
-    #[salsa::invoke(crate::ty::type_for_field)]
+    #[salsa::invoke(crate::ty::field_types_query)]
-    fn type_for_field(&self, field: StructField) -> Ty;
+    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalStructFieldId, Ty>>;
    #[salsa::invoke(crate::ty::callable_item_sig)]
    fn callable_item_signature(&self, def: CallableDef) -> FnSig;
@@ -108,11 +75,14 @@ pub trait HirDatabase: DefDatabase + AstDatabase {
    // Interned IDs for Chalk integration
    #[salsa::interned]
-    fn intern_type_ctor(&self, type_ctor: TypeCtor) -> ids::TypeCtorId;
+    fn intern_type_ctor(&self, type_ctor: TypeCtor) -> crate::ty::TypeCtorId;
    #[salsa::interned]
-    fn intern_chalk_impl(&self, impl_: Impl) -> ids::GlobalImplId;
+    fn intern_chalk_impl(&self, impl_: Impl) -> crate::ty::traits::GlobalImplId;
    #[salsa::interned]
-    fn intern_assoc_ty_value(&self, assoc_ty_value: AssocTyValue) -> ids::AssocTyValueId;
+    fn intern_assoc_ty_value(
+        &self,
+        assoc_ty_value: AssocTyValue,
+    ) -> crate::ty::traits::AssocTyValueId;
    #[salsa::invoke(crate::ty::traits::chalk::associated_ty_data_query)]
    fn associated_ty_data(
diff --git a/crates/ra_hir/src/debug.rs b/crates/ra_hir/src/debug.rs
index 4f3e922c3..7a2810f71 100644
--- a/crates/ra_hir/src/debug.rs
+++ b/crates/ra_hir/src/debug.rs
@@ -1,3 +1,5 @@
+//! XXX: This does not work at the moment.
+//!
 //! printf debugging infrastructure for rust-analyzer.
 //!
 //! When you print a hir type, like a module, using `eprintln!("{:?}", module)`,
@@ -20,9 +22,10 @@
 use std::fmt;
+use hir_expand::HirFileId;
 use ra_db::{CrateId, FileId};
-use crate::{db::HirDatabase, Crate, HirFileId, Module, Name};
+use crate::{db::HirDatabase, Crate, Module, Name};
 impl Crate {
    pub fn debug(self, db: &impl HirDebugDatabase) -> impl fmt::Debug + '_ {
diff --git a/crates/ra_hir/src/diagnostics.rs b/crates/ra_hir/src/diagnostics.rs
index 7d1b64858..dafacba70 100644
--- a/crates/ra_hir/src/diagnostics.rs
+++ b/crates/ra_hir/src/diagnostics.rs
@@ -2,9 +2,10 @@
 use std::any::Any;
+use hir_expand::HirFileId;
 use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};
-use crate::{db::AstDatabase, HirFileId, Name, Source};
+use crate::{db::AstDatabase, Name, Source};
 pub use hir_def::diagnostics::UnresolvedModule;
 pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 6b703d8b4..43fedde7a 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -44,15 +44,15 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
    pub(crate) fn validate_body(&mut self, db: &impl HirDatabase) {
        let body = self.func.body(db);
-        for e in body.exprs() {
+        for e in body.exprs.iter() {
            if let (id, Expr::RecordLit { path, fields, spread }) = e {
                self.validate_record_literal(id, path, fields, *spread, db);
            }
        }
-        let body_expr = &body[body.body_expr()];
+        let body_expr = &body[body.body_expr];
        if let Expr::Block { statements: _, tail: Some(t) } = body_expr {
-            self.validate_results_in_tail_expr(body.body_expr(), *t, db);
+            self.validate_results_in_tail_expr(body.body_expr, *t, db);
        }
    }
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index e8ed04056..529ac8251 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -4,14 +4,14 @@
 //! are splitting the hir.
 use hir_def::{
-    AdtId, AssocItemId, ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId,
+    AdtId, AssocItemId, AttrDefId, ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId,
-    ModuleDefId, StaticId, StructId, TypeAliasId, UnionId,
+    GenericDefId, ModuleDefId, StaticId, StructFieldId, StructId, TypeAliasId, UnionId, VariantId,
 };
 use crate::{
    ty::{CallableDef, TypableDef},
-    Adt, AssocItem, Const, Crate, DefWithBody, EnumVariant, Function, GenericDef, ModuleDef,
+    Adt, AssocItem, AttrDef, Const, Crate, DefWithBody, EnumVariant, Function, GenericDef,
-    Static, TypeAlias,
+    ModuleDef, Static, StructField, TypeAlias, VariantDef,
 };
 impl From<ra_db::CrateId> for Crate {
@@ -70,6 +70,12 @@ impl From<EnumVariantId> for EnumVariant {
    }
 }
+impl From<EnumVariant> for EnumVariantId {
+    fn from(def: EnumVariant) -> Self {
+        EnumVariantId { parent: def.parent.id, local_id: def.id }
+    }
+}
 impl From<ModuleDefId> for ModuleDef {
    fn from(id: ModuleDefId) -> Self {
        match id {
@@ -219,3 +225,35 @@ impl From<CallableDef> for GenericDefId {
        }
    }
 }
+impl From<VariantDef> for VariantId {
+    fn from(def: VariantDef) -> Self {
+        match def {
+            VariantDef::Struct(it) => VariantId::StructId(it.id),
+            VariantDef::EnumVariant(it) => VariantId::EnumVariantId(it.into()),
+        }
+    }
+}
+impl From<StructField> for StructFieldId {
+    fn from(def: StructField) -> Self {
+        StructFieldId { parent: def.parent.into(), local_id: def.id }
+    }
+}
+impl From<AttrDef> for AttrDefId {
+    fn from(def: AttrDef) -> Self {
+        match def {
+            AttrDef::Module(it) => AttrDefId::ModuleId(it.id),
+            AttrDef::StructField(it) => AttrDefId::StructFieldId(it.into()),
+            AttrDef::Adt(it) => AttrDefId::AdtId(it.into()),
+            AttrDef::Function(it) => AttrDefId::FunctionId(it.id),
+            AttrDef::EnumVariant(it) => AttrDefId::EnumVariantId(it.into()),
+            AttrDef::Static(it) => AttrDefId::StaticId(it.id),
+            AttrDef::Const(it) => AttrDefId::ConstId(it.id),
+            AttrDef::Trait(it) => AttrDefId::TraitId(it.id),
+            AttrDef::TypeAlias(it) => AttrDefId::TypeAliasId(it.id),
+            AttrDef::MacroDef(it) => AttrDefId::MacroDefId(it.id),
+        }
+    }
+}
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index b86307c58..1e7c22774 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
-use hir_def::{ModuleId, StructId, StructOrUnionId, UnionId};
+use hir_def::{AstItemDef, LocationCtx, ModuleId, StructId, StructOrUnionId, UnionId};
 use hir_expand::{name::AsName, AstId, MacroDefId, MacroDefKind};
 use ra_syntax::{
    ast::{self, AstNode, NameOwner},
@@ -9,10 +9,9 @@ use ra_syntax::{
 use crate::{
    db::{AstDatabase, DefDatabase, HirDatabase},
-    ids::{AstItemDef, LocationCtx},
+    AssocItem, Const, DefWithBody, Enum, EnumVariant, FieldSource, Function, HasSource, ImplBlock,
-    AssocItem, Const, DefWithBody, Enum, EnumVariant, FieldSource, Function, HasBody, HasSource,
+    Local, MacroDef, Module, ModuleDef, ModuleSource, Source, Static, Struct, StructField, Trait,
-    ImplBlock, Local, MacroDef, Module, ModuleDef, ModuleSource, Source, Static, Struct,
+    TypeAlias, Union, VariantDef,
-    StructField, Trait, TypeAlias, Union, VariantDef,
 };
 pub trait FromSource: Sized {
@@ -105,10 +104,21 @@ impl FromSource for Const {
 impl FromSource for Static {
    type Ast = ast::StaticDef;
    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
-        let id = from_source(db, src)?;
+        let module = match Container::find(db, src.as_ref().map(|it| it.syntax()))? {
-        Some(Static { id })
+            Container::Module(it) => it,
+            Container::Trait(_) | Container::ImplBlock(_) => return None,
+        };
+        module
+            .declarations(db)
+            .into_iter()
+            .filter_map(|it| match it {
+                ModuleDef::Static(it) => Some(it),
+                _ => None,
+            })
+            .find(|it| same_source(&it.source(db), &src))
    }
 }
 impl FromSource for TypeAlias {
    type Ast = ast::TypeAliasDef;
    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
@@ -190,8 +200,7 @@ impl FromSource for StructField {
        variant_def
            .variant_data(db)
            .fields()
-            .into_iter()
+            .iter()
-            .flat_map(|it| it.iter())
            .map(|(id, _)| StructField { parent: variant_def, id })
            .find(|f| f.source(db) == src)
    }
@@ -211,7 +220,7 @@ impl Local {
            };
            Some(res)
        })?;
-        let source_map = parent.body_source_map(db);
+        let (_body, source_map) = db.body_with_source_map(parent.into());
        let src = src.map(ast::Pat::from);
        let pat_id = source_map.node_pat(src.as_ref())?;
        Some(Local { parent, pat_id })
@@ -272,7 +281,9 @@ where
    let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax()));
    let module = Module::from_definition(db, Source::new(src.file_id, module_src))?;
    let ctx = LocationCtx::new(db, module.id, src.file_id);
-    Some(DEF::from_ast(ctx, &src.value))
+    let items = db.ast_id_map(src.file_id);
+    let item_id = items.ast_id(&src.value);
+    Some(DEF::from_ast_id(ctx, item_id))
 }
 enum Container {
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
deleted file mode 100644
index 2b59365fb..000000000
--- a/crates/ra_hir/src/ids.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//! hir makes heavy use of ids: integer (u32) handlers to various things. You
-//! can think of id as a pointer (but without a lifetime) or a file descriptor
-//! (but for hir objects).
-//!
-//! This module defines a bunch of ids we are using. The most important ones are
-//! probably `HirFileId` and `DefId`.
-use ra_db::salsa;
-pub use hir_def::{
-    AstItemDef, ConstId, EnumId, FunctionId, ItemLoc, LocationCtx, StaticId, StructId, TraitId,
-    TypeAliasId,
-};
-pub use hir_expand::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind};
-macro_rules! impl_intern_key {
-    ($name:ident) => {
-        impl salsa::InternKey for $name {
-            fn from_intern_id(v: salsa::InternId) -> Self {
-                $name(v)
-            }
-            fn as_intern_id(&self) -> salsa::InternId {
-                self.0
-            }
-        }
-    };
-}
-/// This exists just for Chalk, because Chalk just has a single `StructId` where
-/// we have different kinds of ADTs, primitive types and special type
-/// constructors like tuples and function pointers.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct TypeCtorId(salsa::InternId);
-impl_intern_key!(TypeCtorId);
-/// This exists just for Chalk, because our ImplIds are only unique per module.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct GlobalImplId(salsa::InternId);
-impl_intern_key!(GlobalImplId);
-/// This exists just for Chalk, because it needs a unique ID for each associated
-/// type value in an impl (even synthetic ones).
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct AssocTyValueId(salsa::InternId);
-impl_intern_key!(AssocTyValueId);
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
deleted file mode 100644
index 774fa1d96..000000000
--- a/crates/ra_hir/src/impl_block.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-//! FIXME: write short doc here
-use hir_def::{resolver::HasResolver, type_ref::TypeRef, AstItemDef};
-use ra_syntax::ast;
-use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
-    ty::Ty,
-    AssocItem, Crate, HasSource, ImplBlock, Module, Source, TraitRef,
-};
-impl HasSource for ImplBlock {
-    type Ast = ast::ImplBlock;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::ImplBlock> {
-        self.id.source(db)
-    }
-}
-impl ImplBlock {
-    pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
-        db.impl_data(self.id).target_trait().cloned()
-    }
-    pub fn target_type(&self, db: &impl DefDatabase) -> TypeRef {
-        db.impl_data(self.id).target_type().clone()
-    }
-    pub fn target_ty(&self, db: &impl HirDatabase) -> Ty {
-        Ty::from_hir(db, &self.id.resolver(db), &self.target_type(db))
-    }
-    pub fn target_trait_ref(&self, db: &impl HirDatabase) -> Option<TraitRef> {
-        let target_ty = self.target_ty(db);
-        TraitRef::from_hir(db, &self.id.resolver(db), &self.target_trait(db)?, Some(target_ty))
-    }
-    pub fn items(&self, db: &impl DefDatabase) -> Vec<AssocItem> {
-        db.impl_data(self.id).items().iter().map(|it| (*it).into()).collect()
-    }
-    pub fn is_negative(&self, db: &impl DefDatabase) -> bool {
-        db.impl_data(self.id).is_negative()
-    }
-    pub fn module(&self, db: &impl DefDatabase) -> Module {
-        self.id.module(db).into()
-    }
-    pub fn krate(&self, db: &impl DefDatabase) -> Crate {
-        Crate { crate_id: self.module(db).id.krate }
-    }
-}
diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs
deleted file mode 100644
index 89fd85f59..000000000
--- a/crates/ra_hir/src/lang_item.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-//! FIXME: write short doc here
-use rustc_hash::FxHashMap;
-use std::sync::Arc;
-use ra_syntax::{ast::AttrsOwner, SmolStr};
-use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
-    Adt, Crate, Enum, Function, HasSource, ImplBlock, Module, ModuleDef, Static, Struct, Trait,
-};
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum LangItemTarget {
-    Enum(Enum),
-    Function(Function),
-    ImplBlock(ImplBlock),
-    Static(Static),
-    Struct(Struct),
-    Trait(Trait),
-}
-impl LangItemTarget {
-    pub(crate) fn krate(&self, db: &impl HirDatabase) -> Option<Crate> {
-        Some(match self {
-            LangItemTarget::Enum(e) => e.module(db).krate(),
-            LangItemTarget::Function(f) => f.module(db).krate(),
-            LangItemTarget::ImplBlock(i) => i.krate(db),
-            LangItemTarget::Static(s) => s.module(db).krate(),
-            LangItemTarget::Struct(s) => s.module(db).krate(),
-            LangItemTarget::Trait(t) => t.module(db).krate(),
-        })
-    }
-}
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub struct LangItems {
-    items: FxHashMap<SmolStr, LangItemTarget>,
-}
-impl LangItems {
-    pub fn target<'a>(&'a self, item: &str) -> Option<&'a LangItemTarget> {
-        self.items.get(item)
-    }
-    /// Salsa query. This will look for lang items in a specific crate.
-    pub(crate) fn crate_lang_items_query(
-        db: &(impl DefDatabase + AstDatabase),
-        krate: Crate,
-    ) -> Arc<LangItems> {
-        let mut lang_items = LangItems::default();
-        if let Some(module) = krate.root_module(db) {
-            lang_items.collect_lang_items_recursive(db, module);
-        }
-        Arc::new(lang_items)
-    }
-    pub(crate) fn module_lang_items_query(
-        db: &(impl DefDatabase + AstDatabase),
-        module: Module,
-    ) -> Option<Arc<LangItems>> {
-        let mut lang_items = LangItems::default();
-        lang_items.collect_lang_items(db, module);
-        if lang_items.items.is_empty() {
-            None
-        } else {
-            Some(Arc::new(lang_items))
-        }
-    }
-    /// Salsa query. Look for a lang item, starting from the specified crate and recursively
-    /// traversing its dependencies.
-    pub(crate) fn lang_item_query(
-        db: &impl DefDatabase,
-        start_crate: Crate,
-        item: SmolStr,
-    ) -> Option<LangItemTarget> {
-        let lang_items = db.crate_lang_items(start_crate);
-        let start_crate_target = lang_items.items.get(&item);
-        if let Some(target) = start_crate_target {
-            Some(*target)
-        } else {
-            for dep in start_crate.dependencies(db) {
-                let dep_crate = dep.krate;
-                let dep_target = db.lang_item(dep_crate, item.clone());
-                if dep_target.is_some() {
-                    return dep_target;
-                }
-            }
-            None
-        }
-    }
-    fn collect_lang_items(&mut self, db: &(impl DefDatabase + AstDatabase), module: Module) {
-        // Look for impl targets
-        for impl_block in module.impl_blocks(db) {
-            let src = impl_block.source(db);
-            if let Some(lang_item_name) = lang_item_name(&src.value) {
-                self.items
-                    .entry(lang_item_name)
-                    .or_insert_with(|| LangItemTarget::ImplBlock(impl_block));
-            }
-        }
-        for def in module.declarations(db) {
-            match def {
-                ModuleDef::Trait(trait_) => {
-                    self.collect_lang_item(db, trait_, LangItemTarget::Trait)
-                }
-                ModuleDef::Adt(Adt::Enum(e)) => self.collect_lang_item(db, e, LangItemTarget::Enum),
-                ModuleDef::Adt(Adt::Struct(s)) => {
-                    self.collect_lang_item(db, s, LangItemTarget::Struct)
-                }
-                ModuleDef::Function(f) => self.collect_lang_item(db, f, LangItemTarget::Function),
-                ModuleDef::Static(s) => self.collect_lang_item(db, s, LangItemTarget::Static),
-                _ => {}
-            }
-        }
-    }
-    fn collect_lang_items_recursive(
-        &mut self,
-        db: &(impl DefDatabase + AstDatabase),
-        module: Module,
-    ) {
-        if let Some(module_lang_items) = db.module_lang_items(module) {
-            self.items.extend(module_lang_items.items.iter().map(|(k, v)| (k.clone(), *v)))
-        }
-        // Look for lang items in the children
-        for child in module.children(db) {
-            self.collect_lang_items_recursive(db, child);
-        }
-    }
-    fn collect_lang_item<T, N>(
-        &mut self,
-        db: &(impl DefDatabase + AstDatabase),
-        item: T,
-        constructor: fn(T) -> LangItemTarget,
-    ) where
-        T: Copy + HasSource<Ast = N>,
-        N: AttrsOwner,
-    {
-        let node = item.source(db).value;
-        if let Some(lang_item_name) = lang_item_name(&node) {
-            self.items.entry(lang_item_name).or_insert_with(|| constructor(item));
-        }
-    }
-}
-fn lang_item_name<T: AttrsOwner>(node: &T) -> Option<SmolStr> {
-    node.attrs()
-        .filter_map(|a| a.as_simple_key_value())
-        .filter(|(key, _)| key == "lang")
-        .map(|(_, val)| val)
-        .nth(0)
-}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 8c6834392..843ce6a88 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -31,12 +31,8 @@ pub mod debug;
 pub mod db;
 pub mod source_binder;
-mod ids;
-mod type_alias;
 mod ty;
-mod impl_block;
 mod expr;
-mod lang_item;
 pub mod diagnostics;
 mod util;
@@ -52,17 +48,13 @@ mod marks;
 pub use crate::{
    code_model::{
-        attrs::{AttrDef, Attrs},
+        src::HasSource, Adt, AssocItem, AttrDef, Const, Container, Crate, CrateDependency,
-        docs::{DocDef, Docs, Documentation},
+        DefWithBody, Docs, Enum, EnumVariant, FieldSource, Function, GenericDef, GenericParam,
-        src::{HasBodySource, HasSource},
+        HasAttrs, ImplBlock, Import, Local, MacroDef, Module, ModuleDef, ModuleSource, ScopeDef,
-        Adt, AssocItem, Const, ConstData, Container, Crate, CrateDependency, DefWithBody, Enum,
+        Static, Struct, StructField, Trait, TypeAlias, Union, VariantDef,
-        EnumVariant, FieldSource, FnData, Function, GenericDef, GenericParam, HasBody, ImplBlock,
-        Local, MacroDef, Module, ModuleDef, ModuleSource, ScopeDef, Static, Struct, StructField,
-        Trait, TypeAlias, Union, VariantDef,
    },
    expr::ExprScopes,
    from_source::FromSource,
-    ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
    source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
    ty::{
        display::HirDisplay,
@@ -73,8 +65,10 @@ pub use crate::{
 pub use hir_def::{
    builtin_type::BuiltinType,
-    nameres::{per_ns::PerNs, raw::ImportId},
+    docs::Documentation,
    path::{Path, PathKind},
    type_ref::Mutability,
 };
-pub use hir_expand::{either::Either, name::Name, Source};
+pub use hir_expand::{
+    either::Either, name::Name, HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, Source,
+};
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 797f90d50..31390bb7f 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -13,7 +13,9 @@ use hir_def::{
    resolver::{self, resolver_for_scope, HasResolver, Resolver, TypeNs, ValueNs},
    DefWithBodyId,
 };
-use hir_expand::{name::AsName, AstId, MacroCallId, MacroCallLoc, MacroFileKind, Source};
+use hir_expand::{
+    name::AsName, AstId, HirFileId, MacroCallId, MacroCallLoc, MacroFileKind, Source,
+};
 use ra_syntax::{
    ast::{self, AstNode},
    match_ast, AstPtr,
@@ -24,11 +26,9 @@ use ra_syntax::{
 use crate::{
    db::HirDatabase,
    expr::{BodySourceMap, ExprScopes, ScopeId},
-    ids::LocationCtx,
    ty::method_resolution::{self, implements_trait},
    Adt, AssocItem, Const, DefWithBody, Either, Enum, EnumVariant, FromSource, Function,
-    GenericParam, HasBody, HirFileId, Local, MacroDef, Module, Name, Path, ScopeDef, Static,
+    GenericParam, Local, MacroDef, Name, Path, ScopeDef, Static, Struct, Trait, Ty, TypeAlias,
-    Struct, Trait, Ty, TypeAlias,
 };
 fn try_get_resolver_for_node(db: &impl HirDatabase, node: Source<&SyntaxNode>) -> Option<Resolver> {
@@ -67,16 +67,12 @@ fn def_with_body_from_child_node(
    db: &impl HirDatabase,
    child: Source<&SyntaxNode>,
 ) -> Option<DefWithBody> {
-    let module_source = crate::ModuleSource::from_child_node(db, child);
-    let module = Module::from_definition(db, Source::new(child.file_id, module_source))?;
-    let ctx = LocationCtx::new(db, module.id, child.file_id);
    child.value.ancestors().find_map(|node| {
        match_ast! {
            match node {
                ast::FnDef(def)  => { return Function::from_source(db, child.with_value(def)).map(DefWithBody::from); },
                ast::ConstDef(def) => { return Const::from_source(db, child.with_value(def)).map(DefWithBody::from); },
-                ast::StaticDef(def) => { Some(Static { id: ctx.to_def(&def) }.into()) },
+                ast::StaticDef(def) => { return Static::from_source(db, child.with_value(def)).map(DefWithBody::from); },
                _ => { None },
            }
        }
@@ -158,8 +154,8 @@ impl SourceAnalyzer {
    ) -> SourceAnalyzer {
        let def_with_body = def_with_body_from_child_node(db, node);
        if let Some(def) = def_with_body {
-            let source_map = def.body_source_map(db);
+            let (_body, source_map) = db.body_with_source_map(def.into());
-            let scopes = def.expr_scopes(db);
+            let scopes = db.expr_scopes(def.into());
            let scope = match offset {
                None => scope_for(&scopes, &source_map, node),
                Some(offset) => scope_for_offset(&scopes, &source_map, node.with_value(offset)),
@@ -169,7 +165,7 @@ impl SourceAnalyzer {
                resolver,
                body_owner: Some(def),
                body_source_map: Some(source_map),
-                infer: Some(def.infer(db)),
+                infer: Some(db.infer(def)),
                scopes: Some(scopes),
                file_id: node.file_id,
            }
@@ -219,6 +215,11 @@ impl SourceAnalyzer {
        self.infer.as_ref()?.field_resolution(expr_id)
    }
+    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<crate::StructField> {
+        let expr_id = self.expr_id(&field.expr()?)?;
+        self.infer.as_ref()?.record_field_resolution(expr_id)
+    }
    pub fn resolve_record_literal(&self, record_lit: &ast::RecordLit) -> Option<crate::VariantDef> {
        let expr_id = self.expr_id(&record_lit.clone().into())?;
        self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
@@ -544,7 +545,7 @@ fn adjust(
 }
 /// Given a `ast::MacroCall`, return what `MacroKindFile` it belongs to.
-/// FIXME: Not completed  
+/// FIXME: Not completed
 fn to_macro_file_kind(macro_call: &ast::MacroCall) -> MacroFileKind {
    let syn = macro_call.syntax();
    let parent = match syn.parent() {
diff --git a/crates/ra_hir/src/test_db.rs b/crates/ra_hir/src/test_db.rs
index 1caa2e875..efee2f658 100644
--- a/crates/ra_hir/src/test_db.rs
+++ b/crates/ra_hir/src/test_db.rs
@@ -2,7 +2,7 @@
 use std::{panic, sync::Arc};
-use hir_def::{db::DefDatabase2, ModuleId};
+use hir_def::{db::DefDatabase, ModuleId};
 use hir_expand::diagnostics::DiagnosticSink;
 use parking_lot::Mutex;
 use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath, SourceDatabase};
@@ -15,7 +15,6 @@ use crate::{db, debug::HirDebugHelper};
    db::InternDatabaseStorage,
    db::AstDatabaseStorage,
    db::DefDatabaseStorage,
-    db::DefDatabase2Storage,
    db::HirDatabaseStorage
 )]
 #[derive(Debug, Default)]
@@ -81,7 +80,7 @@ impl TestDB {
        let crate_graph = self.crate_graph();
        for krate in crate_graph.iter().next() {
            let crate_def_map = self.crate_def_map(krate);
-            for module_id in crate_def_map.modules() {
+            for (module_id, _) in crate_def_map.modules.iter() {
                let module_id = ModuleId { krate, module_id };
                let module = crate::Module::from(module_id);
                module.diagnostics(
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 95b8df181..f62316c1f 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -18,6 +18,7 @@ use std::sync::Arc;
 use std::{fmt, iter, mem};
 use hir_def::{generics::GenericParams, AdtId};
+use ra_db::{impl_intern_key, salsa};
 use crate::{
    db::HirDatabase, expr::ExprId, util::make_mut_slice, Adt, Crate, DefWithBody, FloatTy,
@@ -29,8 +30,9 @@ pub(crate) use autoderef::autoderef;
 pub(crate) use infer::{infer_query, InferTy, InferenceResult};
 pub use lower::CallableDef;
 pub(crate) use lower::{
-    callable_item_sig, generic_defaults_query, generic_predicates_for_param_query,
+    callable_item_sig, field_types_query, generic_defaults_query,
-    generic_predicates_query, type_for_def, type_for_field, Namespace, TypableDef,
+    generic_predicates_for_param_query, generic_predicates_query, type_for_def, Namespace,
+    TypableDef,
 };
 pub(crate) use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
@@ -114,6 +116,13 @@ pub enum TypeCtor {
    Closure { def: DefWithBody, expr: ExprId },
 }
+/// This exists just for Chalk, because Chalk just has a single `StructId` where
+/// we have different kinds of ADTs, primitive types and special type
+/// constructors like tuples and function pointers.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct TypeCtorId(salsa::InternId);
+impl_intern_key!(TypeCtorId);
 impl TypeCtor {
    pub fn num_ty_params(self, db: &impl HirDatabase) -> usize {
        match self {
diff --git a/crates/ra_hir/src/ty/autoderef.rs b/crates/ra_hir/src/ty/autoderef.rs
index b60e4bb31..41c99d227 100644
--- a/crates/ra_hir/src/ty/autoderef.rs
+++ b/crates/ra_hir/src/ty/autoderef.rs
@@ -5,12 +5,13 @@
 use std::iter::successors;
-use hir_def::resolver::Resolver;
+use hir_def::{lang_item::LangItemTarget, resolver::Resolver};
 use hir_expand::name;
 use log::{info, warn};
+use crate::{db::HirDatabase, Trait};
 use super::{traits::Solution, Canonical, Substs, Ty, TypeWalk};
-use crate::db::HirDatabase;
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -41,7 +42,7 @@ fn deref_by_trait(
 ) -> Option<Canonical<Ty>> {
    let krate = resolver.krate()?;
    let deref_trait = match db.lang_item(krate.into(), "deref".into())? {
-        crate::lang_item::LangItemTarget::Trait(t) => t,
+        LangItemTarget::TraitId(t) => Trait::from(t),
        _ => return None,
    };
    let target = deref_trait.associated_type_by_name(db, &name::TARGET_TYPE)?;
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 69b13baef..ddc7d262a 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -22,6 +22,7 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use rustc_hash::FxHashMap;
 use hir_def::{
+    data::{ConstData, FunctionData},
    path::known,
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{Mutability, TypeRef},
@@ -43,8 +44,7 @@ use crate::{
    db::HirDatabase,
    expr::{BindingAnnotation, Body, ExprId, PatId},
    ty::infer::diagnostics::InferenceDiagnostic,
-    Adt, AssocItem, ConstData, DefWithBody, FloatTy, FnData, Function, HasBody, IntTy, Path,
+    Adt, AssocItem, DefWithBody, FloatTy, Function, IntTy, Path, StructField, Trait, VariantDef,
-    StructField, Trait, VariantDef,
 };
 macro_rules! ty_app {
@@ -68,10 +68,10 @@ pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResu
    let resolver = DefWithBodyId::from(def).resolver(db);
    let mut ctx = InferenceContext::new(db, def, resolver);
-    match def {
+    match &def {
-        DefWithBody::Const(ref c) => ctx.collect_const(&c.data(db)),
+        DefWithBody::Const(c) => ctx.collect_const(&db.const_data(c.id)),
-        DefWithBody::Function(ref f) => ctx.collect_fn(&f.data(db)),
+        DefWithBody::Function(f) => ctx.collect_fn(&db.function_data(f.id)),
-        DefWithBody::Static(ref s) => ctx.collect_const(&s.data(db)),
+        DefWithBody::Static(s) => ctx.collect_const(&db.static_data(s.id)),
    }
    ctx.infer_body();
@@ -125,6 +125,8 @@ pub struct InferenceResult {
    method_resolutions: FxHashMap<ExprId, Function>,
    /// For each field access expr, records the field it resolves to.
    field_resolutions: FxHashMap<ExprId, StructField>,
+    /// For each field in record literal, records the field it resolves to.
+    record_field_resolutions: FxHashMap<ExprId, StructField>,
    /// For each struct literal, records the variant it resolves to.
    variant_resolutions: FxHashMap<ExprOrPatId, VariantDef>,
    /// For each associated item record what it resolves to
@@ -142,6 +144,9 @@ impl InferenceResult {
    pub fn field_resolution(&self, expr: ExprId) -> Option<StructField> {
        self.field_resolutions.get(&expr).copied()
    }
+    pub fn record_field_resolution(&self, expr: ExprId) -> Option<StructField> {
+        self.record_field_resolutions.get(&expr).copied()
+    }
    pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantDef> {
        self.variant_resolutions.get(&id.into()).copied()
    }
@@ -215,7 +220,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            coerce_unsized_map: Self::init_coerce_unsized_map(db, &resolver),
            db,
            owner,
-            body: owner.body(db),
+            body: db.body(owner.into()),
            resolver,
        }
    }
@@ -559,21 +564,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    }
    fn collect_const(&mut self, data: &ConstData) {
-        self.return_ty = self.make_ty(data.type_ref());
+        self.return_ty = self.make_ty(&data.type_ref);
    }
-    fn collect_fn(&mut self, data: &FnData) {
+    fn collect_fn(&mut self, data: &FunctionData) {
        let body = Arc::clone(&self.body); // avoid borrow checker problem
-        for (type_ref, pat) in data.params().iter().zip(body.params()) {
+        for (type_ref, pat) in data.params.iter().zip(body.params.iter()) {
            let ty = self.make_ty(type_ref);
            self.infer_pat(*pat, &ty, BindingMode::default());
        }
-        self.return_ty = self.make_ty(data.ret_type());
+        self.return_ty = self.make_ty(&data.ret_type);
    }
    fn infer_body(&mut self) {
-        self.infer_expr(self.body.body_expr(), &Expectation::has_type(self.return_ty.clone()));
+        self.infer_expr(self.body.body_expr, &Expectation::has_type(self.return_ty.clone()));
    }
    fn resolve_into_iter_item(&self) -> Option<TypeAlias> {
diff --git a/crates/ra_hir/src/ty/infer/coerce.rs b/crates/ra_hir/src/ty/infer/coerce.rs
index 0772b9df5..54765da35 100644
--- a/crates/ra_hir/src/ty/infer/coerce.rs
+++ b/crates/ra_hir/src/ty/infer/coerce.rs
@@ -4,13 +4,12 @@
 //!
 //! See: https://doc.rust-lang.org/nomicon/coercions.html
-use hir_def::resolver::Resolver;
+use hir_def::{lang_item::LangItemTarget, resolver::Resolver};
 use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 use crate::{
    db::HirDatabase,
-    lang_item::LangItemTarget,
    ty::{autoderef, Substs, Ty, TypeCtor, TypeWalk},
    Adt, Mutability,
 };
@@ -50,7 +49,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    ) -> FxHashMap<(TypeCtor, TypeCtor), usize> {
        let krate = resolver.krate().unwrap();
        let impls = match db.lang_item(krate.into(), "coerce_unsized".into()) {
-            Some(LangItemTarget::Trait(trait_)) => db.impls_for_trait(krate.into(), trait_),
+            Some(LangItemTarget::TraitId(trait_)) => {
+                db.impls_for_trait(krate.into(), trait_.into())
+            }
            _ => return FxHashMap::default(),
        };
@@ -244,14 +245,17 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                ty_app!(TypeCtor::Adt(Adt::Struct(struct1)), st1),
                ty_app!(TypeCtor::Adt(Adt::Struct(struct2)), st2),
            ) if struct1 == struct2 => {
-                let fields = struct1.fields(self.db);
+                let field_tys = self.db.field_types(struct1.id.into());
-                let (last_field, prev_fields) = fields.split_last()?;
+                let struct_data = self.db.struct_data(struct1.id.0);
+                let mut fields = struct_data.variant_data.fields().iter();
+                let (last_field_id, _data) = fields.next_back()?;
                // Get the generic parameter involved in the last field.
                let unsize_generic_index = {
                    let mut index = None;
                    let mut multiple_param = false;
-                    last_field.ty(self.db).walk(&mut |ty| match ty {
+                    field_tys[last_field_id].walk(&mut |ty| match ty {
                        &Ty::Param { idx, .. } => {
                            if index.is_none() {
                                index = Some(idx);
@@ -270,8 +274,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                // Check other fields do not involve it.
                let mut multiple_used = false;
-                prev_fields.iter().for_each(|field| {
+                fields.for_each(|(field_id, _data)| {
-                    field.ty(self.db).walk(&mut |ty| match ty {
+                    field_tys[field_id].walk(&mut |ty| match ty {
                        &Ty::Param { idx, .. } if idx == unsize_generic_index => {
                            multiple_used = true
                        }
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index 20a7e9352..663ff9435 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -214,19 +214,24 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                self.unify(&ty, &expected.ty);
                let substs = ty.substs().unwrap_or_else(Substs::empty);
+                let field_types =
+                    def_id.map(|it| self.db.field_types(it.into())).unwrap_or_default();
                for (field_idx, field) in fields.iter().enumerate() {
-                    let field_ty = def_id
+                    let field_def = def_id.and_then(|it| match it.field(self.db, &field.name) {
-                        .and_then(|it| match it.field(self.db, &field.name) {
+                        Some(field) => Some(field),
-                            Some(field) => Some(field),
+                        None => {
-                            None => {
+                            self.push_diagnostic(InferenceDiagnostic::NoSuchField {
-                                self.push_diagnostic(InferenceDiagnostic::NoSuchField {
+                                expr: tgt_expr,
-                                    expr: tgt_expr,
+                                field: field_idx,
-                                    field: field_idx,
+                            });
-                                });
+                            None
-                                None
+                        }
-                            }
+                    });
-                        })
+                    if let Some(field_def) = field_def {
-                        .map_or(Ty::Unknown, |field| field.ty(self.db))
+                        self.result.record_field_resolutions.insert(field.expr, field_def);
+                    }
+                    let field_ty = field_def
+                        .map_or(Ty::Unknown, |it| field_types[it.id].clone())
                        .subst(&substs);
                    self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
                }
@@ -250,7 +255,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                            .and_then(|idx| a_ty.parameters.0.get(idx).cloned()),
                        TypeCtor::Adt(Adt::Struct(s)) => s.field(self.db, name).map(|field| {
                            self.write_field_resolution(tgt_expr, field);
-                            field.ty(self.db).subst(&a_ty.parameters)
+                            self.db.field_types(s.id.into())[field.id]
+                                .clone()
+                                .subst(&a_ty.parameters)
                        }),
                        _ => None,
                    },
diff --git a/crates/ra_hir/src/ty/infer/pat.rs b/crates/ra_hir/src/ty/infer/pat.rs
index c125ddfbc..641d61e87 100644
--- a/crates/ra_hir/src/ty/infer/pat.rs
+++ b/crates/ra_hir/src/ty/infer/pat.rs
@@ -27,10 +27,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        let substs = ty.substs().unwrap_or_else(Substs::empty);
+        let field_tys = def.map(|it| self.db.field_types(it.into())).unwrap_or_default();
        for (i, &subpat) in subpats.iter().enumerate() {
            let expected_ty = def
                .and_then(|d| d.field(self.db, &Name::new_tuple_field(i)))
-                .map_or(Ty::Unknown, |field| field.ty(self.db))
+                .map_or(Ty::Unknown, |field| field_tys[field.id].clone())
                .subst(&substs);
            let expected_ty = self.normalize_associated_types_in(expected_ty);
            self.infer_pat(subpat, &expected_ty, default_bm);
@@ -56,10 +57,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        let substs = ty.substs().unwrap_or_else(Substs::empty);
+        let field_tys = def.map(|it| self.db.field_types(it.into())).unwrap_or_default();
        for subpat in subpats {
            let matching_field = def.and_then(|it| it.field(self.db, &subpat.name));
-            let expected_ty =
+            let expected_ty = matching_field
-                matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs);
+                .map_or(Ty::Unknown, |field| field_tys[field.id].clone())
+                .subst(&substs);
            let expected_ty = self.normalize_associated_types_in(expected_ty);
            self.infer_pat(subpat.pat, &expected_ty, default_bm);
        }
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 75c552569..a39beb2a0 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -14,8 +14,9 @@ use hir_def::{
    path::{GenericArg, PathSegment},
    resolver::{HasResolver, Resolver, TypeNs},