71 files changed, 4031 insertions, 1848 deletions
diff --git a/.travis.yml b/.travis.yml
index ecb3b76f4..36fd746dd 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,30 +7,33 @@ before_cache:
 env:
  - CARGO_INCREMENTAL=0
+build: &rust_build
+  language: rust
+  rust: beta
+  script:
+    - cargo gen-tests --verify
+    - cargo gen-syntax --verify
+    - cargo test
 matrix:
  include:
-    - language: rust
+    - os: linux
-      rust: beta
+      <<: *rust_build
-      script:
-        - cargo gen-syntax --verify
-        - cargo gen-tests --verify
-        - cargo test
-    # - language: rust
-    #   rust: nightly
-    #   before_script:
-    #     - rustup component add clippy-preview
-    #     - rustup component add rustfmt-preview
-    #   script:
-    #     - cargo fmt --all -- --check || true
-    #     - cargo clippy
    - language: node_js
      node_js: node
      before_script: false
      script:
        - cd editors/code && npm ci && npm run travis
+    - os: windows
+      if: branch = master
+      before_script:
+        - dos2unix ./crates/ra_syntax/tests/data/parser/**/*.txt
+        - dos2unix ./crates/ra_syntax/tests/data/parser/**/*.rs
+      <<: *rust_build
  allow_failures:
-    - rust nightly
+    - os: windows
 branches:
  only:
diff --git a/Cargo.lock b/Cargo.lock
index 18aac79ab..42a962cf6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -351,6 +351,11 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
+name = "id-arena"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
 name = "idna"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -600,7 +605,10 @@ version = "0.1.0"
 dependencies = [
 "fst 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ra_db 0.1.0",
 "ra_editor 0.1.0",
+ "ra_hir 0.1.0",
 "ra_syntax 0.1.0",
 "rayon 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "relative-path 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -622,6 +630,19 @@ dependencies = [
 ]
 [[package]]
+name = "ra_db"
+version = "0.1.0"
+dependencies = [
+ "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ra_editor 0.1.0",
+ "ra_syntax 0.1.0",
+ "relative-path 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "salsa 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "test_utils 0.1.0",
+]
+[[package]]
 name = "ra_editor"
 version = "0.1.0"
 dependencies = [
@@ -634,6 +655,22 @@ dependencies = [
 ]
 [[package]]
+name = "ra_hir"
+version = "0.1.0"
+dependencies = [
+ "id-arena 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ra_db 0.1.0",
+ "ra_editor 0.1.0",
+ "ra_syntax 0.1.0",
+ "relative-path 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "salsa 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "test_utils 0.1.0",
+]
+[[package]]
 name = "ra_lsp_server"
 version = "0.1.0"
 dependencies = [
@@ -1300,6 +1337,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb"
 "checksum heck 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ea04fa3ead4e05e51a7c806fc07271fdbde4e246a6c6d1efd52e72230b771b82"
 "checksum humansize 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b6cab2627acfc432780848602f3f558f7e9dd427352224b0d9324025796d2a5e"
+"checksum id-arena 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3a7250033feafee46a1cecd2c2616a64aec1d064f38c9ae2bdd297728542843e"
 "checksum idna 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "38f09e0f0b1fb55fdee1f17470ad800da77af5186a1a76c026b679358b7e844e"
 "checksum im 12.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9c7f9bb8aee47fc16d535a705f7867a9fc83bb822e5e1043bb98e77ffeed3c"
 "checksum indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7e81a7c05f79578dbc15793d8b619db9ba32b4577003ef3af1a91c416798c58d"
diff --git a/README.md b/README.md
index 1c5398779..a6195237f 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,6 @@
 # Rust Analyzer
 [![Build Status](https://travis-ci.org/rust-analyzer/rust-analyzer.svg?branch=master)](https://travis-ci.org/rust-analyzer/rust-analyzer)
-[![Build status](https://ci.appveyor.com/api/projects/status/vtt455oi3hjy9uvk/branch/master?svg=true)](https://ci.appveyor.com/project/matklad/rust-analyzer/branch/master)
 Rust Analyzer is an **experimental** modular compiler frontend for the
 Rust language, which aims to lay a foundation for excellent IDE
diff --git a/ROADMAP.md b/ROADMAP.md
new file mode 100644
index 000000000..951a092b4
--- /dev/null
+++ b/ROADMAP.md
@@ -0,0 +1,77 @@
+# Rust Analyzer Roadmap 01
+Written on 2018-11-06, extends approximately to February 2019.
+After that, we should coordinate with the compiler/rls developers to align goals and share code and experience.
+# Overall Goals
+The mission is:
+  * Provide an excellent "code analyzed as you type" IDE experience for the Rust language,
+  * Implement the bulk of the features in Rust itself.
+High-level architecture constraints:
+  * Long-term, replace the current rustc frontend.
+    It's *obvious* that the code should be shared, but OTOH, all great IDEs started as from-scratch rewrites.
+  * Don't hard-code a particular protocol or mode of operation.
+    Produce a library which could be used for implementing an LSP server, or for in-process embedding.
+  * As long as possible, stick with stable Rust (NB: we currently use beta for 2018 edition and salsa).
+# Current Goals
+Ideally, we would be coordinating with the compiler/rls teams, but they are busy working on making Rust 2018 at the moment.
+The sync-up point will happen some time after the edition, probably early 2019.
+In the meantime, the goal is to **experiment**, specifically, to figure out how a from-scratch written RLS might look like.
+## Data Storage and Protocol implementation
+The fundamental part of any architecture is who owns which data, how the data is mutated and how the data is exposed to user.
+For storage we use the [salsa](http://github.com/salsa-rs/salsa) library, which provides a solid model that seems to be the way to go.
+Modification to source files is mostly driven by the language client, but we also should support watching the file system. The current
+file watching implementation is a stub.
+**Action Item:** implement reliable file watching service.
+We also should extract LSP bits as a reusable library. There's already `gen_lsp_server`, but it is pretty limited.
+**Action Item:** try using `gen_lsp_server` in more than one language server, for example for TOML and Nix.
+The ideal architecture for `gen_lsp_server` is still unclear. I'd rather avoid futures: they bring significant runtime complexity
+(call stacks become insane) and the performance benefits are negligible for our use case (one thread per request is perfectly OK given
+the low amount of requests a language server receives). The current interface is based on crossbeam-channel, but it's not clear
+if that is the best choice.
+## Low-effort, high payoff features
+Implementing 20% of type inference will give use 80% of completion.
+Thus it makes sense to partially implement name resolution, type inference and trait matching, even though there is a chance that
+this code is replaced later on when we integrate with the compiler
+Specifically, we need to:
+* **Action Item:** implement path resolution, so that we get completion in imports and such.
+* **Action Item:** implement simple type inference, so that we get completion for inherent methods.
+* **Action Item:** implement nicer completion infrastructure, so that we have icons, snippets, doc comments, after insert callbacks, ...
+## Dragons to kill
+To make experiments most effective, we should try to prototype solutions for the hardest problems.
+In the case of Rust, the two hardest problems are:
+  * Conditional compilation and source/model mismatch.
+    A single source file might correspond to several entities in the semantic model.
+    For example, different cfg flags produce effectively different crates from the same source.
+  * Macros are intertwined with name resolution in a single fix-point iteration algorithm.
+    This is just plain hard to implement, but also interacts poorly with on-demand.
+For the first bullet point, we need to design descriptors infra and explicit mapping step between sources and semantic model, which is intentionally fuzzy in one direction.
+The **action item** here is basically "write code, see what works, keep high-level picture in mind".
+For the second bullet point, there's hope that salsa with its deep memoization will result in a fast enough solution even without being fully on-demand.
+Again, the **action item** is to write the code and see what works. Salsa itself uses macros heavily, so it should be a great test.
diff --git a/appveyor.yml b/appveyor.yml
deleted file mode 100644
index a32a1e7b8..000000000
--- a/appveyor.yml
+++ /dev/null
@@ -1,19 +0,0 @@
-os: Visual Studio 2015
-install:
-  - curl https://win.rustup.rs/ --output rustup-init.exe
-  - rustup-init -yv --default-toolchain beta --default-host x86_64-pc-windows-msvc
-  - set PATH=%PATH%;%USERPROFILE%\.cargo\bin
-  - rustc -vV
-  - cargo -vV
-build: false
-test_script:
-  - cargo test
-branches:
-  only:
-    - staging
-    - master
-    - trying
diff --git a/crates/gen_lsp_server/src/lib.rs b/crates/gen_lsp_server/src/lib.rs
index e45a6b5e2..5dab8f408 100644
--- a/crates/gen_lsp_server/src/lib.rs
+++ b/crates/gen_lsp_server/src/lib.rs
@@ -1,4 +1,4 @@
-//! A language server scaffold, exposing synchroneous crossbeam-channel based API.
+//! A language server scaffold, exposing a synchronous crossbeam-channel based API.
 //! This crate handles protocol handshaking and parsing messages, while you
 //! control the message dispatch loop yourself.
 //!
diff --git a/crates/gen_lsp_server/src/msg.rs b/crates/gen_lsp_server/src/msg.rs
index e0d0aeab5..e1b27c808 100644
--- a/crates/gen_lsp_server/src/msg.rs
+++ b/crates/gen_lsp_server/src/msg.rs
@@ -94,7 +94,7 @@ impl RawRequest {
        R::Params: Serialize,
    {
        RawRequest {
-            id: id,
+            id,
            method: R::METHOD.to_string(),
            params: to_value(params).unwrap(),
        }
diff --git a/crates/ra_analysis/Cargo.toml b/crates/ra_analysis/Cargo.toml
index 908ee1c81..fe9765a66 100644
--- a/crates/ra_analysis/Cargo.toml
+++ b/crates/ra_analysis/Cargo.toml
@@ -11,6 +11,9 @@ rayon = "1.0.2"
 fst = "0.3.1"
 salsa = "0.8.0"
 rustc-hash = "1.0"
+parking_lot = "0.6.4"
 ra_syntax = { path = "../ra_syntax" }
 ra_editor = { path = "../ra_editor" }
+ra_db = { path = "../ra_db" }
+hir = { path = "../ra_hir", package = "ra_hir" }
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_analysis/src/completion/mod.rs b/crates/ra_analysis/src/completion/mod.rs
index 2e082705e..e5ba92acd 100644
--- a/crates/ra_analysis/src/completion/mod.rs
+++ b/crates/ra_analysis/src/completion/mod.rs
@@ -2,18 +2,16 @@ mod reference_completion;
 use ra_editor::find_node_at_offset;
 use ra_syntax::{
-    algo::find_leaf_at_offset,
    algo::visit::{visitor_ctx, VisitorCtx},
    ast,
    AstNode, AtomEdit,
    SyntaxNodeRef,
 };
+use ra_db::SyntaxDatabase;
 use rustc_hash::{FxHashMap};
 use crate::{
-    db::{self, SyntaxDatabase},
+    db,
-    descriptors::{DescriptorDatabase, module::ModuleSource},
-    input::{FilesDatabase},
    Cancelable, FilePosition
 };
@@ -31,39 +29,21 @@ pub(crate) fn completions(
    db: &db::RootDatabase,
    position: FilePosition,
 ) -> Cancelable<Option<Vec<CompletionItem>>> {
-    let original_file = db.file_syntax(position.file_id);
+    let original_file = db.source_file(position.file_id);
    // Insert a fake ident to get a valid parse tree
    let file = {
        let edit = AtomEdit::insert(position.offset, "intellijRulezz".to_string());
        original_file.reparse(&edit)
    };
-    let leaf = match find_leaf_at_offset(original_file.syntax(), position.offset).left_biased() {
+    let module = ctry!(hir::Module::guess_from_position(db, position)?);
-        None => return Ok(None),
-        Some(it) => it,
-    };
-    let source_root_id = db.file_source_root(position.file_id);
-    let module_tree = db.module_tree(source_root_id)?;
-    let module_source = ModuleSource::for_node(position.file_id, leaf);
-    let module_id = match module_tree.any_module_for_source(module_source) {
-        None => return Ok(None),
-        Some(it) => it,
-    };
    let mut res = Vec::new();
    let mut has_completions = false;
    // First, let's try to complete a reference to some declaration.
    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
        has_completions = true;
-        reference_completion::completions(
+        reference_completion::completions(&mut res, db, &module, &file, name_ref)?;
-            &mut res,
-            db,
-            source_root_id,
-            &module_tree,
-            module_id,
-            &file,
-            name_ref,
-        )?;
        // special case, `trait T { fn foo(i_am_a_name_ref) {} }`
        if is_node::<ast::Param>(name_ref.syntax()) {
            param_completions(name_ref.syntax(), &mut res);
@@ -219,9 +199,9 @@ mod tests {
                <|>
            }
            ",
-            r#"[CompletionItem { label: "Foo", lookup: None, snippet: None },
+            r#"[CompletionItem { label: "quux", lookup: None, snippet: None },
-                   CompletionItem { label: "Baz", lookup: None, snippet: None },
+                CompletionItem { label: "Foo", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
+                CompletionItem { label: "Baz", lookup: None, snippet: None }]"#,
        );
    }
@@ -236,6 +216,20 @@ mod tests {
    }
    #[test]
+    fn test_completion_self_path() {
+        check_scope_completion(
+            r"
+            use self::m::<|>;
+            mod m {
+                struct Bar;
+            }
+            ",
+            r#"[CompletionItem { label: "Bar", lookup: None, snippet: None }]"#,
+        );
+    }
+    #[test]
    fn test_completion_mod_scope_nested() {
        check_scope_completion(
            r"
@@ -245,8 +239,8 @@ mod tests {
                fn quux() { <|> }
            }
            ",
-            r#"[CompletionItem { label: "Bar", lookup: None, snippet: None },
+            r#"[CompletionItem { label: "quux", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
+                CompletionItem { label: "Bar", lookup: None, snippet: None }]"#,
        );
    }
diff --git a/crates/ra_analysis/src/completion/reference_completion.rs b/crates/ra_analysis/src/completion/reference_completion.rs
index 6c5fd0be6..e1a2d5241 100644
--- a/crates/ra_analysis/src/completion/reference_completion.rs
+++ b/crates/ra_analysis/src/completion/reference_completion.rs
@@ -6,23 +6,23 @@ use ra_syntax::{
    ast::{self, LoopBodyOwner},
    SyntaxKind::*,
 };
+use     hir::{
+        self,
+        FnScopes,
+        Def,
+        Path,
+};
 use crate::{
    db::RootDatabase,
-    input::{SourceRootId},
    completion::CompletionItem,
-    descriptors::module::{ModuleId, ModuleTree},
-    descriptors::function::FnScopes,
-    descriptors::DescriptorDatabase,
    Cancelable
 };
 pub(super) fn completions(
    acc: &mut Vec<CompletionItem>,
    db: &RootDatabase,
-    source_root_id: SourceRootId,
+    module: &hir::Module,
-    module_tree: &ModuleTree,
-    module_id: ModuleId,
    file: &SourceFileNode,
    name_ref: ast::NameRef,
 ) -> Cancelable<()> {
@@ -40,25 +40,28 @@ pub(super) fn completions(
                complete_expr_snippets(acc);
            }
-            let module_scope = db.module_scope(source_root_id, module_id)?;
+            let module_scope = module.scope(db)?;
            acc.extend(
                module_scope
                    .entries()
-                    .iter()
+                    .filter(|(_name, res)| {
-                    .filter(|entry| {
                        // Don't expose this item
-                        !entry.ptr().range().is_subrange(&name_ref.syntax().range())
+                        match res.import {
+                            None => true,
+                            Some(import) => {
+                                let range = import.range(db, module.source().file_id());
+                                !range.is_subrange(&name_ref.syntax().range())
+                            }
+                        }
                    })
-                    .map(|entry| CompletionItem {
+                    .map(|(name, _res)| CompletionItem {
-                        label: entry.name().to_string(),
+                        label: name.to_string(),
                        lookup: None,
                        snippet: None,
                    }),
            );
        }
-        NameRefKind::CratePath(path) => {
+        NameRefKind::Path(path) => complete_path(acc, db, module, path)?,
-            complete_path(acc, db, source_root_id, module_tree, module_id, path)?
-        }
        NameRefKind::BareIdentInMod => {
            let name_range = name_ref.syntax().range();
            let top_node = name_ref
@@ -82,8 +85,8 @@ enum NameRefKind<'a> {
    LocalRef {
        enclosing_fn: Option<ast::FnDef<'a>>,
    },
-    /// NameRef is the last segment in crate:: path
+    /// NameRef is the last segment in some path
-    CratePath(Vec<ast::NameRef<'a>>),
+    Path(Path),
    /// NameRef is bare identifier at the module's root.
    /// Used for keyword completion
    BareIdentInMod,
@@ -105,8 +108,10 @@ fn classify_name_ref(name_ref: ast::NameRef) -> Option<NameRefKind> {
    let parent = name_ref.syntax().parent()?;
    if let Some(segment) = ast::PathSegment::cast(parent) {
        let path = segment.parent_path();
-        if let Some(crate_path) = crate_path(path) {
+        if let Some(path) = Path::from_ast(path) {
-            return Some(NameRefKind::CratePath(crate_path));
+            if !path.is_ident() {
+                return Some(NameRefKind::Path(path));
+            }
        }
        if path.qualifier().is_none() {
            let enclosing_fn = name_ref
@@ -120,32 +125,6 @@ fn classify_name_ref(name_ref: ast::NameRef) -> Option<NameRefKind> {
    None
 }
-fn crate_path(mut path: ast::Path) -> Option<Vec<ast::NameRef>> {
-    let mut res = Vec::new();
-    loop {
-        let segment = path.segment()?;
-        match segment.kind()? {
-            ast::PathSegmentKind::Name(name) => res.push(name),
-            ast::PathSegmentKind::CrateKw => break,
-            ast::PathSegmentKind::SelfKw | ast::PathSegmentKind::SuperKw => return None,
-        }
-        path = qualifier(path)?;
-    }
-    res.reverse();
-    return Some(res);
-    fn qualifier(path: ast::Path) -> Option<ast::Path> {
-        if let Some(q) = path.qualifier() {
-            return Some(q);
-        }
-        // TODO: this bottom up traversal is not too precise.
-        // Should we handle do a top-down analysiss, recording results?
-        let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
-        let use_tree = use_tree_list.parent_use_tree();
-        use_tree.path()
-    }
-}
 fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
    let mut shadowed = FxHashSet::default();
    acc.extend(
@@ -171,18 +150,24 @@ fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<Completi
 fn complete_path(
    acc: &mut Vec<CompletionItem>,
    db: &RootDatabase,
-    source_root_id: SourceRootId,
+    module: &hir::Module,
-    module_tree: &ModuleTree,
+    mut path: Path,
-    module_id: ModuleId,
-    crate_path: Vec<ast::NameRef>,
 ) -> Cancelable<()> {
-    let target_module_id = match find_target_module(module_tree, module_id, crate_path) {
+    if path.segments.is_empty() {
+        return Ok(());
+    }
+    path.segments.pop();
+    let def_id = match module.resolve_path(db, path)? {
        None => return Ok(()),
        Some(it) => it,
    };
-    let module_scope = db.module_scope(source_root_id, target_module_id)?;
+    let target_module = match def_id.resolve(db)? {
-    let completions = module_scope.entries().iter().map(|entry| CompletionItem {
+        Def::Module(it) => it,
-        label: entry.name().to_string(),
+        Def::Item => return Ok(()),
+    };
+    let module_scope = target_module.scope(db)?;
+    let completions = module_scope.entries().map(|(name, _res)| CompletionItem {
+        label: name.to_string(),
        lookup: None,
        snippet: None,
    });
@@ -190,19 +175,6 @@ fn complete_path(
    Ok(())
 }
-fn find_target_module(
-    module_tree: &ModuleTree,
-    module_id: ModuleId,
-    mut crate_path: Vec<ast::NameRef>,
-) -> Option<ModuleId> {
-    crate_path.pop();
-    let mut target_module = module_id.root(&module_tree);
-    for name in crate_path {
-        target_module = target_module.child(module_tree, name.text().as_str())?;
-    }
-    Some(target_module)
-}
 fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
    acc.push(CompletionItem {
        label: "tfn".to_string(),
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 194f1a6b0..df2ef293d 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,23 +1,22 @@
 use std::sync::Arc;
-use ra_editor::LineIndex;
-use ra_syntax::{SourceFileNode, SyntaxNode};
 use salsa::{self, Database};
+use ra_db::{LocationIntener, BaseDatabase};
+use hir::{self, DefId, DefLoc, FnId, SourceItemId};
 use crate::{
-    db,
+    symbol_index,
-    descriptors::{
-        DescriptorDatabase, FnScopesQuery, FnSyntaxQuery, ModuleScopeQuery, ModuleTreeQuery,
-        SubmodulesQuery,
-    },
-    symbol_index::SymbolIndex,
-    syntax_ptr::SyntaxPtr,
-    Cancelable, Canceled, FileId,
 };
 #[derive(Debug)]
 pub(crate) struct RootDatabase {
    runtime: salsa::Runtime<RootDatabase>,
+    id_maps: Arc<IdMaps>,
+}
+#[derive(Debug, Default)]
+struct IdMaps {
+    fns: LocationIntener<SourceItemId, FnId>,
+    defs: LocationIntener<DefLoc, DefId>,
 }
 impl salsa::Database for RootDatabase {
@@ -29,90 +28,68 @@ impl salsa::Database for RootDatabase {
 impl Default for RootDatabase {
    fn default() -> RootDatabase {
        let mut db = RootDatabase {
-            runtime: Default::default(),
+            runtime: salsa::Runtime::default(),
+            id_maps: Default::default(),
        };
-        db.query_mut(crate::input::SourceRootQuery)
+        db.query_mut(ra_db::SourceRootQuery)
-            .set(crate::input::WORKSPACE, Default::default());
+            .set(ra_db::WORKSPACE, Default::default());
-        db.query_mut(crate::input::CrateGraphQuery)
+        db.query_mut(ra_db::CrateGraphQuery)
            .set((), Default::default());
-        db.query_mut(crate::input::LibrariesQuery)
+        db.query_mut(ra_db::LibrariesQuery)
            .set((), Default::default());
        db
    }
 }
-pub(crate) fn check_canceled(db: &impl salsa::Database) -> Cancelable<()> {
-    if db.salsa_runtime().is_current_revision_canceled() {
-        Err(Canceled)
-    } else {
-        Ok(())
-    }
-}
 impl salsa::ParallelDatabase for RootDatabase {
    fn snapshot(&self) -> salsa::Snapshot<RootDatabase> {
        salsa::Snapshot::new(RootDatabase {
            runtime: self.runtime.snapshot(self),
+            id_maps: self.id_maps.clone(),
        })
    }
 }
-salsa::database_storage! {
+impl BaseDatabase for RootDatabase {}
-    pub(crate) struct RootDatabaseStorage for RootDatabase {
-        impl crate::input::FilesDatabase {
+impl AsRef<LocationIntener<DefLoc, DefId>> for RootDatabase {
-            fn file_text() for crate::input::FileTextQuery;
+    fn as_ref(&self) -> &LocationIntener<DefLoc, DefId> {
-            fn file_source_root() for crate::input::FileSourceRootQuery;
+        &self.id_maps.defs
-            fn source_root() for crate::input::SourceRootQuery;
-            fn libraries() for crate::input::LibrariesQuery;
-            fn library_symbols() for crate::input::LibrarySymbolsQuery;
-            fn crate_graph() for crate::input::CrateGraphQuery;
-        }
-        impl SyntaxDatabase {
-            fn file_syntax() for FileSyntaxQuery;
-            fn file_lines() for FileLinesQuery;
-            fn file_symbols() for FileSymbolsQuery;
-            fn resolve_syntax_ptr() for ResolveSyntaxPtrQuery;
-        }
-        impl DescriptorDatabase {
-            fn module_tree() for ModuleTreeQuery;
-            fn module_descriptor() for SubmodulesQuery;
-            fn module_scope() for ModuleScopeQuery;
-            fn fn_syntax() for FnSyntaxQuery;
-            fn fn_scopes() for FnScopesQuery;
-        }
    }
 }
-salsa::query_group! {
+impl AsRef<LocationIntener<hir::SourceItemId, FnId>> for RootDatabase {
-    pub(crate) trait SyntaxDatabase: crate::input::FilesDatabase {
+    fn as_ref(&self) -> &LocationIntener<hir::SourceItemId, FnId> {
-        fn file_syntax(file_id: FileId) -> SourceFileNode {
+        &self.id_maps.fns
-            type FileSyntaxQuery;
+    }
+}
+salsa::database_storage! {
+    pub(crate) struct RootDatabaseStorage for RootDatabase {
+        impl ra_db::FilesDatabase {
+            fn file_text() for ra_db::FileTextQuery;
+            fn file_source_root() for ra_db::FileSourceRootQuery;
+            fn source_root() for ra_db::SourceRootQuery;
+            fn libraries() for ra_db::LibrariesQuery;
+            fn crate_graph() for ra_db::CrateGraphQuery;
        }
-        fn file_lines(file_id: FileId) -> Arc<LineIndex> {
+        impl ra_db::SyntaxDatabase {
-            type FileLinesQuery;
+            fn source_file() for ra_db::SourceFileQuery;
+            fn file_lines() for ra_db::FileLinesQuery;
        }
-        fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
+        impl symbol_index::SymbolsDatabase {
-            type FileSymbolsQuery;
+            fn file_symbols() for symbol_index::FileSymbolsQuery;
+            fn library_symbols() for symbol_index::LibrarySymbolsQuery;
        }
-        fn resolve_syntax_ptr(ptr: SyntaxPtr) -> SyntaxNode {
+        impl hir::db::HirDatabase {
-            type ResolveSyntaxPtrQuery;
+            fn module_tree() for hir::db::ModuleTreeQuery;
-            // Don't retain syntax trees in memory
+            fn fn_scopes() for hir::db::FnScopesQuery;
-            storage volatile;
+            fn file_items() for hir::db::SourceFileItemsQuery;
-            use fn crate::syntax_ptr::resolve_syntax_ptr;
+            fn file_item() for hir::db::FileItemQuery;
+            fn input_module_items() for hir::db::InputModuleItemsQuery;
+            fn item_map() for hir::db::ItemMapQuery;
+            fn fn_syntax() for hir::db::FnSyntaxQuery;
+            fn submodules() for hir::db::SubmodulesQuery;
        }
    }
 }
-fn file_syntax(db: &impl SyntaxDatabase, file_id: FileId) -> SourceFileNode {
-    let text = db.file_text(file_id);
-    SourceFileNode::parse(&*text)
-}
-fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
-    let text = db.file_text(file_id);
-    Arc::new(LineIndex::new(&*text))
-}
-fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
-    db::check_canceled(db)?;
-    let syntax = db.file_syntax(file_id);
-    Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
-}
diff --git a/crates/ra_analysis/src/descriptors/function/imp.rs b/crates/ra_analysis/src/descriptors/function/imp.rs
deleted file mode 100644
index a989a04cd..000000000
--- a/crates/ra_analysis/src/descriptors/function/imp.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use std::sync::Arc;
-use ra_syntax::ast::{AstNode, FnDef, FnDefNode};
-use crate::descriptors::{
-    function::{FnId, FnScopes},
-    DescriptorDatabase,
-};
-/// Resolve `FnId` to the corresponding `SyntaxNode`
-/// TODO: this should return something more type-safe then `SyntaxNode`
-pub(crate) fn fn_syntax(db: &impl DescriptorDatabase, fn_id: FnId) -> FnDefNode {
-    let syntax = db.resolve_syntax_ptr(fn_id.0);
-    FnDef::cast(syntax.borrowed()).unwrap().owned()
-}
-pub(crate) fn fn_scopes(db: &impl DescriptorDatabase, fn_id: FnId) -> Arc<FnScopes> {
-    let syntax = db.fn_syntax(fn_id);
-    let res = FnScopes::new(syntax.borrowed());
-    Arc::new(res)
-}
diff --git a/crates/ra_analysis/src/descriptors/mod.rs b/crates/ra_analysis/src/descriptors/mod.rs
deleted file mode 100644
index 56bde3849..000000000
--- a/crates/ra_analysis/src/descriptors/mod.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-pub(crate) mod function;
-pub(crate) mod module;
-use std::sync::Arc;
-use ra_syntax::{
-    ast::{self, AstNode, FnDefNode},
-    TextRange,
-};
-use crate::{
-    db::SyntaxDatabase,
-    descriptors::function::{resolve_local_name, FnId, FnScopes},
-    descriptors::module::{ModuleId, ModuleScope, ModuleTree, ModuleSource},
-    input::SourceRootId,
-    syntax_ptr::LocalSyntaxPtr,
-    Cancelable,
-};
-salsa::query_group! {
-    pub(crate) trait DescriptorDatabase: SyntaxDatabase {
-        fn module_tree(source_root_id: SourceRootId) -> Cancelable<Arc<ModuleTree>> {
-            type ModuleTreeQuery;
-            use fn module::imp::module_tree;
-        }
-        fn submodules(source: ModuleSource) -> Cancelable<Arc<Vec<module::imp::Submodule>>> {
-            type SubmodulesQuery;
-            use fn module::imp::submodules;
-        }
-        fn module_scope(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<ModuleScope>> {
-            type ModuleScopeQuery;
-            use fn module::imp::module_scope;
-        }
-        fn fn_syntax(fn_id: FnId) -> FnDefNode {
-            type FnSyntaxQuery;
-            // Don't retain syntax trees in memory
-            storage volatile;
-            use fn function::imp::fn_syntax;
-        }
-        fn fn_scopes(fn_id: FnId) -> Arc<FnScopes> {
-            type FnScopesQuery;
-            use fn function::imp::fn_scopes;
-        }
-    }
-}
-#[derive(Debug)]
-pub struct ReferenceDescriptor {
-    pub range: TextRange,
-    pub name: String,
-}
-#[derive(Debug)]
-pub struct DeclarationDescriptor<'a> {
-    pat: ast::BindPat<'a>,
-    pub range: TextRange,
-}
-impl<'a> DeclarationDescriptor<'a> {
-    pub fn new(pat: ast::BindPat) -> DeclarationDescriptor {
-        let range = pat.syntax().range();
-        DeclarationDescriptor { pat, range }
-    }
-    pub fn find_all_refs(&self) -> Vec<ReferenceDescriptor> {
-        let name_ptr = LocalSyntaxPtr::new(self.pat.syntax());
-        let fn_def = match self.pat.syntax().ancestors().find_map(ast::FnDef::cast) {
-            Some(def) => def,
-            None => return Default::default(),
-        };
-        let fn_scopes = FnScopes::new(fn_def);
-        let refs: Vec<_> = fn_def
-            .syntax()
-            .descendants()
-            .filter_map(ast::NameRef::cast)
-            .filter(|name_ref| match resolve_local_name(*name_ref, &fn_scopes) {
-                None => false,
-                Some(entry) => entry.ptr() == name_ptr,
-            })
-            .map(|name_ref| ReferenceDescriptor {
-                name: name_ref.syntax().text().to_string(),
-                range: name_ref.syntax().range(),
-            })
-            .collect();
-        refs
-    }
-}
diff --git a/crates/ra_analysis/src/descriptors/module/mod.rs b/crates/ra_analysis/src/descriptors/module/mod.rs
deleted file mode 100644
index bc1148b22..000000000
--- a/crates/ra_analysis/src/descriptors/module/mod.rs
+++ /dev/null
@@ -1,236 +0,0 @@
-pub(super) mod imp;
-pub(crate) mod scope;
-use ra_syntax::{
-    ast::{self, AstNode, NameOwner},
-    SmolStr, SyntaxNode, SyntaxNodeRef,
-};
-use relative_path::RelativePathBuf;
-use crate::{db::SyntaxDatabase, syntax_ptr::SyntaxPtr, FileId};
-pub(crate) use self::scope::ModuleScope;
-/// Phisically, rust source is organized as a set of files, but logically it is
-/// organized as a tree of modules. Usually, a single file corresponds to a
-/// single module, but it is not nessary the case.
-///
-/// Module encapsulate the logic of transitioning from the fuzzy world of files
-/// (which can have multiple parents) to the precise world of modules (which
-/// always have one parent).
-#[derive(Debug, PartialEq, Eq, Hash)]
-pub(crate) struct ModuleTree {
-    mods: Vec<ModuleData>,
-    links: Vec<LinkData>,
-}
-impl ModuleTree {
-    pub(crate) fn modules_for_source(&self, source: ModuleSource) -> Vec<ModuleId> {
-        self.mods
-            .iter()
-            .enumerate()
-            .filter(|(_idx, it)| it.source == source)
-            .map(|(idx, _)| ModuleId(idx as u32))
-            .collect()
-    }
-    pub(crate) fn any_module_for_source(&self, source: ModuleSource) -> Option<ModuleId> {
-        self.modules_for_source(source).pop()
-    }
-}
-/// `ModuleSource` is the syntax tree element that produced this module:
-/// either a file, or an inlinde module.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub(crate) enum ModuleSource {
-    SourceFile(FileId),
-    #[allow(dead_code)]
-    Module(SyntaxPtr),
-}
-/// An owned syntax node for a module. Unlike `ModuleSource`,
-/// this holds onto the AST for the whole file.
-enum ModuleSourceNode {
-    SourceFile(ast::SourceFileNode),
-    Module(ast::ModuleNode),
-}
-#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
-pub(crate) struct ModuleId(u32);
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub(crate) struct LinkId(u32);
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum Problem {
-    UnresolvedModule {
-        candidate: RelativePathBuf,
-    },
-    NotDirOwner {
-        move_to: RelativePathBuf,
-        candidate: RelativePathBuf,
-    },
-}
-impl ModuleId {
-    pub(crate) fn source(self, tree: &ModuleTree) -> ModuleSource {
-        tree.module(self).source
-    }
-    pub(crate) fn parent_link(self, tree: &ModuleTree) -> Option<LinkId> {
-        tree.module(self).parent
-    }
-    pub(crate) fn parent(self, tree: &ModuleTree) -> Option<ModuleId> {
-        let link = self.parent_link(tree)?;
-        Some(tree.link(link).owner)
-    }
-    pub(crate) fn root(self, tree: &ModuleTree) -> ModuleId {
-        let mut curr = self;
-        let mut i = 0;
-        while let Some(next) = curr.parent(tree) {
-            curr = next;
-            i += 1;
-            // simplistic cycle detection
-            if i > 100 {
-                return self;
-            }
-        }
-        curr
-    }
-    pub(crate) fn child(self, tree: &ModuleTree, name: &str) -> Option<ModuleId> {
-        let link = tree
-            .module(self)
-            .children
-            .iter()
-            .map(|&it| tree.link(it))
-            .find(|it| it.name == name)?;
-        Some(*link.points_to.first()?)
-    }
-    pub(crate) fn problems(
-        self,
-        tree: &ModuleTree,
-        db: &impl SyntaxDatabase,
-    ) -> Vec<(SyntaxNode, Problem)> {
-        tree.module(self)
-            .children
-            .iter()
-            .filter_map(|&it| {
-                let p = tree.link(it).problem.clone()?;
-                let s = it.bind_source(tree, db);
-                let s = s.borrowed().name().unwrap().syntax().owned();
-                Some((s, p))
-            })
-            .collect()
-    }
-}
-impl LinkId {
-    pub(crate) fn owner(self, tree: &ModuleTree) -> ModuleId {
-        tree.link(self).owner
-    }
-    pub(crate) fn bind_source<'a>(
-        self,
-        tree: &ModuleTree,
-        db: &impl SyntaxDatabase,
-    ) -> ast::ModuleNode {
-        let owner = self.owner(tree);
-        match owner.source(tree).resolve(db) {
-            ModuleSourceNode::SourceFile(root) => {
-                let ast = imp::modules(root.borrowed())
-                    .find(|(name, _)| name == &tree.link(self).name)
-                    .unwrap()
-                    .1;
-                ast.owned()
-            }
-            ModuleSourceNode::Module(it) => it,
-        }
-    }
-}
-#[derive(Debug, PartialEq, Eq, Hash)]
-struct ModuleData {
-    source: ModuleSource,
-    parent: Option<LinkId>,
-    children: Vec<LinkId>,
-}
-impl ModuleSource {
-    pub(crate) fn for_node(file_id: FileId, node: SyntaxNodeRef) -> ModuleSource {
-        for node in node.ancestors() {
-            if let Some(m) = ast::Module::cast(node) {
-                if !m.has_semi() {
-                    return ModuleSource::new_inline(file_id, m);
-                }
-            }
-        }
-        ModuleSource::SourceFile(file_id)
-    }
-    pub(crate) fn new_inline(file_id: FileId, module: ast::Module) -> ModuleSource {
-        assert!(!module.has_semi());
-        let ptr = SyntaxPtr::new(file_id, module.syntax());
-        ModuleSource::Module(ptr)
-    }
-    pub(crate) fn as_file(self) -> Option<FileId> {
-        match self {
-            ModuleSource::SourceFile(f) => Some(f),
-            ModuleSource::Module(..) => None,
-        }
-    }
-    pub(crate) fn file_id(self) -> FileId {
-        match self {
-            ModuleSource::SourceFile(f) => f,
-            ModuleSource::Module(ptr) => ptr.file_id(),
-        }
-    }
-    fn resolve(self, db: &impl SyntaxDatabase) -> ModuleSourceNode {
-        match self {
-            ModuleSource::SourceFile(file_id) => {
-                let syntax = db.file_syntax(file_id);
-                ModuleSourceNode::SourceFile(syntax.ast().owned())
-            }
-            ModuleSource::Module(ptr) => {
-                let syntax = db.resolve_syntax_ptr(ptr);
-                let syntax = syntax.borrowed();
-                let module = ast::Module::cast(syntax).unwrap();
-                ModuleSourceNode::Module(module.owned())
-            }
-        }
-    }
-}
-#[derive(Hash, Debug, PartialEq, Eq)]
-struct LinkData {
-    owner: ModuleId,
-    name: SmolStr,
-    points_to: Vec<ModuleId>,
-    problem: Option<Problem>,
-}
-impl ModuleTree {
-    fn module(&self, id: ModuleId) -> &ModuleData {
-        &self.mods[id.0 as usize]
-    }
-    fn module_mut(&mut self, id: ModuleId) -> &mut ModuleData {
-        &mut self.mods[id.0 as usize]
-    }
-    fn link(&self, id: LinkId) -> &LinkData {
-        &self.links[id.0 as usize]
-    }
-    fn link_mut(&mut self, id: LinkId) -> &mut LinkData {
-        &mut self.links[id.0 as usize]
-    }
-    fn push_mod(&mut self, data: ModuleData) -> ModuleId {
-        let id = ModuleId(self.mods.len() as u32);
-        self.mods.push(data);
-        id
-    }
-    fn push_link(&mut self, data: LinkData) -> LinkId {
-        let id = LinkId(self.links.len() as u32);
-        self.mods[data.owner.0 as usize].children.push(id);
-        self.links.push(data);
-        id
-    }
-}
diff --git a/crates/ra_analysis/src/descriptors/module/scope.rs b/crates/ra_analysis/src/descriptors/module/scope.rs
deleted file mode 100644
index 4490228e4..000000000
--- a/crates/ra_analysis/src/descriptors/module/scope.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-//! Backend for module-level scope resolution & completion
-use ra_syntax::{ast, AstNode, SmolStr};
-use crate::syntax_ptr::LocalSyntaxPtr;
-/// `ModuleScope` contains all named items declared in the scope.
-#[derive(Debug, PartialEq, Eq)]
-pub(crate) struct ModuleScope {
-    entries: Vec<Entry>,
-}
-/// `Entry` is a single named declaration iside a module.
-#[derive(Debug, PartialEq, Eq)]
-pub(crate) struct Entry {
-    ptr: LocalSyntaxPtr,
-    kind: EntryKind,
-    name: SmolStr,
-}
-#[derive(Debug, PartialEq, Eq)]
-enum EntryKind {
-    Item,
-    Import,
-}
-impl ModuleScope {
-    pub(super) fn new<'a>(items: impl Iterator<Item = ast::ModuleItem<'a>>) -> ModuleScope {
-        let mut entries = Vec::new();
-        for item in items {
-            let entry = match item {
-                ast::ModuleItem::StructDef(item) => Entry::new(item),
-                ast::ModuleItem::EnumDef(item) => Entry::new(item),
-                ast::ModuleItem::FnDef(item) => Entry::new(item),
-                ast::ModuleItem::ConstDef(item) => Entry::new(item),
-                ast::ModuleItem::StaticDef(item) => Entry::new(item),
-                ast::ModuleItem::TraitDef(item) => Entry::new(item),
-                ast::ModuleItem::TypeDef(item) => Entry::new(item),
-                ast::ModuleItem::Module(item) => Entry::new(item),
-                ast::ModuleItem::UseItem(item) => {
-                    if let Some(tree) = item.use_tree() {
-                        collect_imports(tree, &mut entries);
-                    }
-                    continue;
-                }
-                ast::ModuleItem::ExternCrateItem(_) | ast::ModuleItem::ImplItem(_) => continue,
-            };
-            entries.extend(entry)
-        }
-        ModuleScope { entries }
-    }
-    pub fn entries(&self) -> &[Entry] {
-        self.entries.as_slice()
-    }
-}
-impl Entry {
-    fn new<'a>(item: impl ast::NameOwner<'a>) -> Option<Entry> {
-        let name = item.name()?;
-        Some(Entry {
-            name: name.text(),
-            ptr: LocalSyntaxPtr::new(name.syntax()),
-            kind: EntryKind::Item,
-        })
-    }
-    fn new_import(path: ast::Path) -> Option<Entry> {
-        let name_ref = path.segment()?.name_ref()?;
-        Some(Entry {
-            name: name_ref.text(),
-            ptr: LocalSyntaxPtr::new(name_ref.syntax()),
-            kind: EntryKind::Import,
-        })
-    }
-    pub fn name(&self) -> &SmolStr {
-        &self.name
-    }
-    pub fn ptr(&self) -> LocalSyntaxPtr {
-        self.ptr
-    }
-}
-fn collect_imports(tree: ast::UseTree, acc: &mut Vec<Entry>) {
-    if let Some(use_tree_list) = tree.use_tree_list() {
-        return use_tree_list
-            .use_trees()
-            .for_each(|it| collect_imports(it, acc));
-    }
-    if let Some(path) = tree.path() {
-        acc.extend(Entry::new_import(path));
-    }
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use ra_syntax::{ast::ModuleItemOwner, SourceFileNode};
-    fn do_check(code: &str, expected: &[&str]) {
-        let file = SourceFileNode::parse(&code);
-        let scope = ModuleScope::new(file.ast().items());
-        let actual = scope.entries.iter().map(|it| it.name()).collect::<Vec<_>>();
-        assert_eq!(expected, actual.as_slice());
-    }
-    #[test]
-    fn test_module_scope() {
-        do_check(
-            "
-            struct Foo;
-            enum Bar {}
-            mod baz {}
-            fn quux() {}
-            use x::{
-                y::z,
-                t,
-            };
-            type T = ();
-        ",
-            &["Foo", "Bar", "baz", "quux", "z", "t", "T"],
-        )
-    }
-}
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 74c248a96..f5cb3550e 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -1,91 +1,33 @@
 use std::{
    fmt,
-    hash::{Hash, Hasher},
    sync::Arc,
 };
 use ra_editor::{self, find_node_at_offset, FileSymbol, LineIndex, LocalEdit};
 use ra_syntax::{
    ast::{self, ArgListOwner, Expr, NameOwner},
-    AstNode, SourceFileNode, SmolStr,
+    AstNode, SourceFileNode,
    SyntaxKind::*,
    SyntaxNodeRef, TextRange, TextUnit,
 };
+use ra_db::{FilesDatabase, SourceRoot, SourceRootId, WORKSPACE, SyntaxDatabase, SourceFileQuery};
 use rayon::prelude::*;
-use relative_path::RelativePath;
 use rustc_hash::FxHashSet;
 use salsa::{Database, ParallelDatabase};
+use hir::{
+    self,
+    FnSignatureInfo,
+    Problem,
+};
 use crate::{
    completion::{completions, CompletionItem},
-    db::{self, FileSyntaxQuery, SyntaxDatabase},
+    db,
-    descriptors::{
+    symbol_index::{SymbolIndex, SymbolsDatabase},
-        function::{FnDescriptor, FnId},
+    AnalysisChange, Cancelable, CrateId, Diagnostic, FileId,
-        module::{ModuleSource, ModuleTree, Problem},
-        DeclarationDescriptor, DescriptorDatabase,
-    },
-    input::{FilesDatabase, SourceRoot, SourceRootId, WORKSPACE},
-    symbol_index::SymbolIndex,
-    AnalysisChange, Cancelable, CrateGraph, CrateId, Diagnostic, FileId, FileResolver,
    FileSystemEdit, FilePosition, Query, SourceChange, SourceFileNodeEdit,
 };
-#[derive(Clone, Debug)]
-pub(crate) struct FileResolverImp {
-    inner: Arc<FileResolver>,
-}
-impl PartialEq for FileResolverImp {
-    fn eq(&self, other: &FileResolverImp) -> bool {
-        self.inner() == other.inner()
-    }
-}
-impl Eq for FileResolverImp {}
-impl Hash for FileResolverImp {
-    fn hash<H: Hasher>(&self, hasher: &mut H) {
-        self.inner().hash(hasher);
-    }
-}
-impl FileResolverImp {
-    pub(crate) fn new(inner: Arc<FileResolver>) -> FileResolverImp {
-        FileResolverImp { inner }
-    }
-    pub(crate) fn file_stem(&self, file_id: FileId) -> String {
-        self.inner.file_stem(file_id)
-    }
-    pub(crate) fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId> {
-        self.inner.resolve(file_id, path)
-    }
-    fn inner(&self) -> *const FileResolver {
-        &*self.inner
-    }
-}
-impl Default for FileResolverImp {
-    fn default() -> FileResolverImp {
-        #[derive(Debug)]
-        struct DummyResolver;
-        impl FileResolver for DummyResolver {
-            fn file_stem(&self, _file_: FileId) -> String {
-                panic!("file resolver not set")
-            }
-            fn resolve(
-                &self,
-                _file_id: FileId,
-                _path: &::relative_path::RelativePath,
-            ) -> Option<FileId> {
-                panic!("file resolver not set")
-            }
-        }
-        FileResolverImp {
-            inner: Arc::new(DummyResolver),
-        }
-    }
-}
 #[derive(Debug, Default)]
 pub(crate) struct AnalysisHostImpl {
    db: db::RootDatabase,
@@ -102,7 +44,7 @@ impl AnalysisHostImpl {
        for (file_id, text) in change.files_changed {
            self.db
-                .query_mut(crate::input::FileTextQuery)
+                .query_mut(ra_db::FileTextQuery)
                .set(file_id, Arc::new(text))
        }
        if !(change.files_added.is_empty() && change.files_removed.is_empty()) {
@@ -112,22 +54,22 @@ impl AnalysisHostImpl {
            let mut source_root = SourceRoot::clone(&self.db.source_root(WORKSPACE));
            for (file_id, text) in change.files_added {
                self.db
-                    .query_mut(crate::input::FileTextQuery)
+                    .query_mut(ra_db::FileTextQuery)
                    .set(file_id, Arc::new(text));
                self.db
-                    .query_mut(crate::input::FileSourceRootQuery)
+                    .query_mut(ra_db::FileSourceRootQuery)
-                    .set(file_id, crate::input::WORKSPACE);
+                    .set(file_id, ra_db::WORKSPACE);
                source_root.files.insert(file_id);
            }
            for file_id in change.files_removed {
                self.db
-                    .query_mut(crate::input::FileTextQuery)
+                    .query_mut(ra_db::FileTextQuery)
                    .set(file_id, Arc::new(String::new()));
                source_root.files.remove(&file_id);
            }
            source_root.file_resolver = file_resolver;
            self.db
-                .query_mut(crate::input::SourceRootQuery)
+                .query_mut(ra_db::SourceRootQuery)
                .set(WORKSPACE, Arc::new(source_root))
        }
        if !change.libraries_added.is_empty() {
@@ -138,11 +80,16 @@ impl AnalysisHostImpl {
                let mut files = FxHashSet::default();
                for (file_id, text) in library.files {
                    files.insert(file_id);
+                    log::debug!(
+                        "library file: {:?} {:?}",
+                        file_id,
+                        library.file_resolver.debug_path(file_id)
+                    );
                    self.db
-                        .query_mut(crate::input::FileSourceRootQuery)
+                        .query_mut(ra_db::FileSourceRootQuery)
                        .set_constant(file_id, source_root_id);
                    self.db
-                        .query_mut(crate::input::FileTextQuery)
+                        .query_mut(ra_db::FileTextQuery)
                        .set_constant(file_id, Arc::new(text));
                }
                let source_root = SourceRoot {
@@ -150,19 +97,19 @@ impl AnalysisHostImpl {
                    file_resolver: library.file_resolver,
                };
                self.db
-                    .query_mut(crate::input::SourceRootQuery)
+                    .query_mut(ra_db::SourceRootQuery)
                    .set(source_root_id, Arc::new(source_root));
                self.db
-                    .query_mut(crate::input::LibrarySymbolsQuery)
+                    .query_mut(crate::symbol_index::LibrarySymbolsQuery)
                    .set(source_root_id, Arc::new(library.symbol_index));
            }
            self.db
-                .query_mut(crate::input::LibrariesQuery)
+                .query_mut(ra_db::LibrariesQuery)
                .set((), Arc::new(libraries));
        }
        if let Some(crate_graph) = change.crate_graph {
            self.db
-                .query_mut(crate::input::CrateGraphQuery)
+                .query_mut(ra_db::CrateGraphQuery)
                .set((), Arc::new(crate_graph))
        }
    }
@@ -181,7 +128,7 @@ impl fmt::Debug for AnalysisImpl {
 impl AnalysisImpl {
    pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
-        self.db.file_syntax(file_id)
+        self.db.source_file(file_id)
    }
    pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
        self.db.file_lines(file_id)
@@ -212,59 +159,48 @@ impl AnalysisImpl {
                .collect()
        };
        self.db
-            .query(FileSyntaxQuery)
+            .query(SourceFileQuery)
            .sweep(salsa::SweepStrategy::default().discard_values());
        Ok(query.search(&buf))
    }
-    fn module_tree(&self, file_id: FileId) -> Cancelable<Arc<ModuleTree>> {
+    /// This return `Vec`: a module may be included from several places. We
-        let source_root = self.db.file_source_root(file_id);
+    /// don't handle this case yet though, so the Vec has length at most one.
-        self.db.module_tree(source_root)
-    }
    pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
-        let module_tree = self.module_tree(position.file_id)?;
+        let descr = match hir::Module::guess_from_position(&*self.db, position)? {
-        let file = self.db.file_syntax(position.file_id);
+            None => return Ok(Vec::new()),
-        let module_source = match find_node_at_offset::<ast::Module>(file.syntax(), position.offset)
+            Some(it) => it,
-        {
-            Some(m) if !m.has_semi() => ModuleSource::new_inline(position.file_id, m),
-            _ => ModuleSource::SourceFile(position.file_id),
        };
+        let (file_id, decl) = match descr.parent_link_source(&*self.db) {
-        let res = module_tree
+            None => return Ok(Vec::new()),
-            .modules_for_source(module_source)
+            Some(it) => it,
-            .into_iter()
+        };
-            .filter_map(|module_id| {
+        let decl = decl.borrowed();
-                let link = module_id.parent_link(&module_tree)?;
+        let decl_name = decl.name().unwrap();
-                let file_id = link.owner(&module_tree).source(&module_tree).file_id();
+        let sym = FileSymbol {
-                let decl = link.bind_source(&module_tree, &*self.db);
+            name: decl_name.text(),
-                let decl = decl.borrowed();
+            node_range: decl_name.syntax().range(),
+            kind: MODULE,
-                let decl_name = decl.name().unwrap();
+        };
+        Ok(vec![(file_id, sym)])
-                let sym = FileSymbol {
-                    name: decl_name.text(),
-                    node_range: decl_name.syntax().range(),
-                    kind: MODULE,
-                };
-                Some((file_id, sym))
-            })
-            .collect();
-        Ok(res)
    }
+    /// Returns `Vec` for the same reason as `parent_module`
    pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
-        let module_tree = self.module_tree(file_id)?;
+        let descr = match hir::Module::guess_from_file_id(&*self.db, file_id)? {
-        let crate_graph = self.db.crate_graph();
+            None => return Ok(Vec::new()),
-        let res = module_tree
+            Some(it) => it,
-            .modules_for_source(ModuleSource::SourceFile(file_id))
+        };
-            .into_iter()
+        let root = descr.crate_root();
-            .map(|it| it.root(&module_tree))
+        let file_id = root
-            .filter_map(|it| it.source(&module_tree).as_file())
+            .source()
-            .filter_map(|it| crate_graph.crate_id_for_crate_root(it))
+            .as_file()
-            .collect();
+            .expect("root module always has a file as a source");
-        Ok(res)
+        let crate_graph = self.db.crate_graph();
+        let crate_id = crate_graph.crate_id_for_crate_root(file_id);
+        Ok(crate_id.into_iter().collect())
    }
    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
-        self.db.crate_graph().crate_roots[&crate_id]
+        self.db.crate_graph().crate_root(crate_id)
    }
    pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
        completions(&self.db, position)
@@ -273,51 +209,51 @@ impl AnalysisImpl {
        &self,
        position: FilePosition,
    ) -> Cancelable<Vec<(FileId, FileSymbol)>> {
-        let module_tree = self.module_tree(position.file_id)?;
+        let file = self.db.source_file(position.file_id);
-        let file = self.db.file_syntax(position.file_id);
        let syntax = file.syntax();
        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
-            // First try to resolve the symbol locally
+            if let Some(fn_descr) =
-            return if let Some((name, range)) =
+                hir::Function::guess_for_name_ref(&*self.db, position.file_id, name_ref)
-                resolve_local_name(&self.db, position.file_id, name_ref)
            {
-                let mut vec = vec![];
+                let scope = fn_descr.scope(&*self.db);
-                vec.push((
+                // First try to resolve the symbol locally
-                    position.file_id,
+                return if let Some(entry) = scope.resolve_local_name(name_ref) {
-                    FileSymbol {
+                    let mut vec = vec![];
-                        name,
+                    vec.push((
-                        node_range: range,
+                        position.file_id,
-                        kind: NAME,
+                        FileSymbol {
-                    },
+                            name: entry.name().clone(),
-                ));
+                            node_range: entry.ptr().range(),
-                Ok(vec)
+                            kind: NAME,
-            } else {
+                        },
-                // If that fails try the index based approach.
+                    ));
-                self.index_resolve(name_ref)
+                    Ok(vec)
-            };
+                } else {
+                    // If that fails try the index based approach.
+                    self.index_resolve(name_ref)
+                };
+            }
        }
        if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
            if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
                if module.has_semi() {
-                    let file_ids = self.resolve_module(&*module_tree, position.file_id, module);
+                    let parent_module =
+                        hir::Module::guess_from_file_id(&*self.db, position.file_id)?;
-                    let res = file_ids
+                    let child_name = module.name();
-                        .into_iter()
+                    match (parent_module, child_name) {
-                        .map(|id| {
+                        (Some(parent_module), Some(child_name)) => {
-                            let name = module
+                            if let Some(child) = parent_module.child(&child_name.text()) {
-                                .name()
+                                let file_id = child.source().file_id();
-                                .map(|n| n.text())
+                                let symbol = FileSymbol {
-                                .unwrap_or_else(|| SmolStr::new(""));
+                                    name: child_name.text(),
-                            let symbol = FileSymbol {
+                                    node_range: TextRange::offset_len(0.into(), 0.into()),
-                                name,
+                                    kind: MODULE,
-                                node_range: TextRange::offset_len(0.into(), 0.into()),
+                                };
-                                kind: MODULE,
+                                return Ok(vec![(file_id, symbol)]);
-                            };
+                            }
-                            (id, symbol)
+                        }
-                        })
+                        _ => (),
-                        .collect();
+                    }
-                    return Ok(res);
                }
            }
        }
@@ -325,32 +261,42 @@ impl AnalysisImpl {
    }
    pub fn find_all_refs(&self, position: FilePosition) -> Vec<(FileId, TextRange)> {
-        let file = self.db.file_syntax(position.file_id);
+        let file = self.db.source_file(position.file_id);
-        let syntax = file.syntax();
        // Find the binding associated with the offset
-        let maybe_binding =
+        let (binding, descr) = match find_binding(&self.db, &file, position) {
-            find_node_at_offset::<ast::BindPat>(syntax, position.offset).or_else(|| {
-                let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
-                let resolved = resolve_local_name(&self.db, position.file_id, name_ref)?;
-                find_node_at_offset::<ast::BindPat>(syntax, resolved.1.end())
-            });
-        let binding = match maybe_binding {
            None => return Vec::new(),
            Some(it) => it,
        };
-        let decl = DeclarationDescriptor::new(binding);
+        let mut ret = vec![(position.file_id, binding.syntax().range())];
-        let mut ret = vec![(position.file_id, decl.range)];
        ret.extend(
-            decl.find_all_refs()
+            descr
+                .scope(&*self.db)
+                .find_all_refs(binding)
                .into_iter()
                .map(|ref_desc| (position.file_id, ref_desc.range)),
        );
-        ret
+        return ret;
+        fn find_binding<'a>(
+            db: &db::RootDatabase,
+            source_file: &'a SourceFileNode,
+            position: FilePosition,
+        ) -> Option<(ast::BindPat<'a>, hir::Function)> {
+            let syntax = source_file.syntax();
+            if let Some(binding) = find_node_at_offset::<ast::BindPat>(syntax, position.offset) {
+                let descr = hir::Function::guess_for_bind_pat(db, position.file_id, binding)?;
+                return Some((binding, descr));
+            };
+            let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
+            let descr = hir::Function::guess_for_name_ref(db, position.file_id, name_ref)?;
+            let scope = descr.scope(db);
+            let resolved = scope.resolve_local_name(name_ref)?;
+            let resolved = resolved.ptr().resolve(source_file);
+            let binding = find_node_at_offset::<ast::BindPat>(syntax, resolved.range().end())?;
+            Some((binding, descr))
+        }
    }
    pub fn doc_comment_for(
@@ -358,14 +304,13 @@ impl AnalysisImpl {
        file_id: FileId,
        symbol: FileSymbol,
    ) -> Cancelable<Option<String>> {
-        let file = self.db.file_syntax(file_id);
+        let file = self.db.source_file(file_id);
        Ok(symbol.docs(&file))
    }
    pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
-        let module_tree = self.module_tree(file_id)?;
+        let syntax = self.db.source_file(file_id);
-        let syntax = self.db.file_syntax(file_id);
        let mut res = ra_editor::diagnostics(&syntax)
            .into_iter()
@@ -375,8 +320,8 @@ impl AnalysisImpl {
                fix: None,
            })
            .collect::<Vec<_>>();
-        if let Some(m) = module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) {
+        if let Some(m) = hir::Module::guess_from_file_id(&*self.db, file_id)? {
-            for (name_node, problem) in m.problems(&module_tree, &*self.db) {
+            for (name_node, problem) in m.problems(&*self.db) {
                let diag = match problem {
                    Problem::UnresolvedModule { candidate } => {
                        let create_file = FileSystemEdit::CreateFile {
@@ -452,27 +397,22 @@ impl AnalysisImpl {
    pub fn resolve_callable(
        &self,
        position: FilePosition,
-    ) -> Cancelable<Option<(FnDescriptor, Option<usize>)>> {
+    ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
-        let file = self.db.file_syntax(position.file_id);
+        let file = self.db.source_file(position.file_id);
        let syntax = file.syntax();
        // Find the calling expression and it's NameRef
-        let calling_node = match FnCallNode::with_node(syntax, position.offset) {
+        let calling_node = ctry!(FnCallNode::with_node(syntax, position.offset));
-            Some(node) => node,
+        let name_ref = ctry!(calling_node.name_ref());
-            None => return Ok(None),
-        };
-        let name_ref = match calling_node.name_ref() {
-            Some(name) => name,
-            None => return Ok(None),
-        };
        // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
        let file_symbols = self.index_resolve(name_ref)?;
-        for (fn_fiel_id, fs) in file_symbols {
+        for (fn_file_id, fs) in file_symbols {
            if fs.kind == FN_DEF {
-                let fn_file = self.db.file_syntax(fn_fiel_id);
+                let fn_file = self.db.source_file(fn_file_id);
                if let Some(fn_def) = find_node_at_offset(fn_file.syntax(), fs.node_range.start()) {
-                    if let Some(descriptor) = FnDescriptor::new(fn_def) {
+                    let descr = hir::Function::guess_from_source(&*self.db, fn_file_id, fn_def);
+                    if let Some(descriptor) = descr.signature_info(&*self.db) {
                        // If we have a calling expression let's find which argument we are on
                        let mut current_parameter = None;
@@ -526,27 +466,6 @@ impl AnalysisImpl {
        query.limit(4);
        self.world_symbols(query)
    }
-    fn resolve_module(
-        &self,
-        module_tree: &ModuleTree,
-        file_id: FileId,
-        module: ast::Module,
-    ) -> Vec<FileId> {
-        let name = match module.name() {
-            Some(name) => name.text(),
-            None => return Vec::new(),
-        };
-        let module_id = match module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) {
-            Some(id) => id,
-            None => return Vec::new(),
-        };
-        module_id
-            .child(module_tree, name.as_str())
-            .and_then(|it| it.source(&module_tree).as_file())
-            .into_iter()
-            .collect()
-    }
 }
 impl SourceChange {
@@ -566,16 +485,6 @@ impl SourceChange {
    }
 }
-impl CrateGraph {
-    fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
-        let (&crate_id, _) = self
-            .crate_roots
-            .iter()
-            .find(|(_crate_id, &root_id)| root_id == file_id)?;
-        Some(crate_id)
-    }
-}
 enum FnCallNode<'a> {
    CallExpr(ast::CallExpr<'a>),
    MethodCallExpr(ast::MethodCallExpr<'a>),
@@ -614,16 +523,3 @@ impl<'a> FnCallNode<'a> {
        }
    }
 }
-fn resolve_local_name(
-    db: &db::RootDatabase,
-    file_id: FileId,
-    name_ref: ast::NameRef,
-) -> Option<(SmolStr, TextRange)> {
-    let fn_def = name_ref.syntax().ancestors().find_map(ast::FnDef::cast)?;
-    let fn_id = FnId::new(file_id, fn_def);
-    let scopes = db.fn_scopes(fn_id);
-    let scope_entry = crate::descriptors::function::resolve_local_name(name_ref, &scopes)?;
-    let syntax = db.resolve_syntax_ptr(scope_entry.ptr().into_global(file_id));
-    Some((scope_entry.name().clone(), syntax.range()))
-}
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index ad0273edc..12df580ba 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -1,5 +1,5 @@
 //! ra_analyzer crate is the brain of Rust analyzer. It relies on the `salsa`
-//! crate, which provides and incremental on-deman database of facts.
+//! crate, which provides and incremental on-demand database of facts.
 extern crate fst;
 extern crate ra_editor;
@@ -9,47 +9,45 @@ extern crate relative_path;
 extern crate rustc_hash;
 extern crate salsa;
+macro_rules! ctry {
+    ($expr:expr) => {
+        match $expr {
+            None => return Ok(None),
+            Some(it) => it,
+        }
+    };
+}
 mod db;
-mod input;
 mod imp;
 mod completion;
-mod descriptors;
 mod symbol_index;
-mod syntax_ptr;
 pub mod mock_analysis;
 use std::{fmt, sync::Arc};
 use ra_syntax::{AtomEdit, SourceFileNode, TextRange, TextUnit};
+use ra_db::FileResolverImp;
 use rayon::prelude::*;
 use relative_path::RelativePathBuf;
 use crate::{
-    imp::{AnalysisHostImpl, AnalysisImpl, FileResolverImp},
+    imp::{AnalysisHostImpl, AnalysisImpl},
    symbol_index::SymbolIndex,
 };
 pub use crate::{
    completion::CompletionItem,
-    descriptors::function::FnDescriptor,
-    input::{CrateGraph, CrateId, FileId, FileResolver},
 };
 pub use ra_editor::{
    FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable, RunnableKind, StructureNode,
 };
+pub use hir::FnSignatureInfo;
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub use ra_db::{
-pub struct Canceled;
+    Canceled, Cancelable, FilePosition,
+    CrateGraph, CrateId, FileId, FileResolver
-pub type Cancelable<T> = Result<T, Canceled>;
+};
-impl std::fmt::Display for Canceled {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        fmt.write_str("Canceled")
-    }
-}
-impl std::error::Error for Canceled {}
 #[derive(Default)]
 pub struct AnalysisChange {
@@ -119,12 +117,6 @@ impl AnalysisHost {
    }
 }
-#[derive(Clone, Copy, Debug)]
-pub struct FilePosition {
-    pub file_id: FileId,
-    pub offset: TextUnit,
-}
 #[derive(Debug)]
 pub struct SourceChange {
    pub label: String,
@@ -294,7 +286,7 @@ impl Analysis {
    pub fn resolve_callable(
        &self,
        position: FilePosition,
-    ) -> Cancelable<Option<(FnDescriptor, Option<usize>)>> {
+    ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
        self.imp.resolve_callable(position)
    }
 }
diff --git a/crates/ra_analysis/src/mock_analysis.rs b/crates/ra_analysis/src/mock_analysis.rs
index 8e8f969f4..0d9a7a147 100644
--- a/crates/ra_analysis/src/mock_analysis.rs
+++ b/crates/ra_analysis/src/mock_analysis.rs
@@ -1,9 +1,10 @@
 use std::sync::Arc;
-use relative_path::{RelativePath, RelativePathBuf};
+use relative_path::{RelativePathBuf};
 use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
+use ra_db::mock::FileMap;
-use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FileResolver, FilePosition};
+use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FilePosition};
 /// Mock analysis is used in test to bootstrap an AnalysisHost/Analysis
 /// from a set of in-memory files.
@@ -76,16 +77,15 @@ impl MockAnalysis {
    }
    pub fn analysis_host(self) -> AnalysisHost {
        let mut host = AnalysisHost::default();
-        let mut file_map = Vec::new();
+        let mut file_map = FileMap::default();
        let mut change = AnalysisChange::new();
-        for (id, (path, contents)) in self.files.into_iter().enumerate() {
+        for (path, contents) in self.files.into_iter() {
-            let file_id = FileId((id + 1) as u32);
            assert!(path.starts_with('/'));
            let path = RelativePathBuf::from_path(&path[1..]).unwrap();
+            let file_id = file_map.add(path);
            change.add_file(file_id, contents);
-            file_map.push((file_id, path));
        }
-        change.set_file_resolver(Arc::new(FileMap(file_map)));
+        change.set_file_resolver(Arc::new(file_map));
        host.apply_change(change);
        host
    }
@@ -113,29 +113,3 @@ pub fn single_file_with_position(code: &str) -> (Analysis, FilePosition) {
    let pos = mock.add_file_with_position("/main.rs", code);
    (mock.analysis(), pos)
 }
-#[derive(Debug)]
-struct FileMap(Vec<(FileId, RelativePathBuf)>);
-impl FileMap {
-    fn iter<'a>(&'a self) -> impl Iterator<Item = (FileId, &'a RelativePath)> + 'a {
-        self.0
-            .iter()
-            .map(|(id, path)| (*id, path.as_relative_path()))
-    }
-    fn path(&self, id: FileId) -> &RelativePath {
-        self.iter().find(|&(it, _)| it == id).unwrap().1
-    }
-}
-impl FileResolver for FileMap {
-    fn file_stem(&self, id: FileId) -> String {
-        self.path(id).file_stem().unwrap().to_string()
-    }
-    fn resolve(&self, id: FileId, rel: &RelativePath) -> Option<FileId> {
-        let path = self.path(id).join(rel).normalize();
-        let id = self.iter().find(|&(_, p)| path == p)?.0;
-        Some(id)
-    }
-}
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index 3a0667ecd..b48a37229 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -4,14 +4,36 @@ use std::{
 };
 use fst::{self, Streamer};
-use ra_editor::{file_symbols, FileSymbol};
+use ra_editor::{self, FileSymbol};
 use ra_syntax::{
    SourceFileNode,
    SyntaxKind::{self, *},
 };
+use ra_db::{SyntaxDatabase, SourceRootId};
 use rayon::prelude::*;
-use crate::{FileId, Query};
+use crate::{
+    Cancelable,
+    FileId, Query,
+};
+salsa::query_group! {
+    pub(crate) trait SymbolsDatabase: SyntaxDatabase {
+        fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
+            type FileSymbolsQuery;
+        }
+        fn library_symbols(id: SourceRootId) -> Arc<SymbolIndex> {
+            type LibrarySymbolsQuery;
+            storage input;
+        }
+    }
+}
+fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
+    db.check_canceled()?;
+    let syntax = db.source_file(file_id);
+    Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
+}
 #[derive(Default, Debug)]
 pub(crate) struct SymbolIndex {
@@ -39,7 +61,7 @@ impl SymbolIndex {
    ) -> SymbolIndex {
        let mut symbols = files
            .flat_map(|(file_id, file)| {
-                file_symbols(&file)
+                ra_editor::file_symbols(&file)
                    .into_iter()
                    .map(move |symbol| (symbol.name.as_str().to_lowercase(), (file_id, symbol)))
                    .collect::<Vec<_>>()
diff --git a/crates/ra_analysis/src/syntax_ptr.rs b/crates/ra_analysis/src/syntax_ptr.rs
deleted file mode 100644
index 194b94584..000000000
--- a/crates/ra_analysis/src/syntax_ptr.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, TextRange};
-use crate::db::SyntaxDatabase;
-use crate::FileId;
-pub(crate) fn resolve_syntax_ptr(db: &impl SyntaxDatabase, ptr: SyntaxPtr) -> SyntaxNode {
-    let syntax = db.file_syntax(ptr.file_id);
-    ptr.local.resolve(&syntax)
-}
-/// SyntaxPtr is a cheap `Copy` id which identifies a particular syntax node,
-/// without retaining syntax tree in memory. You need to explicitly `resolve`
-/// `SyntaxPtr` to get a `SyntaxNode`
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct SyntaxPtr {
-    file_id: FileId,
-    local: LocalSyntaxPtr,
-}
-impl SyntaxPtr {
-    pub(crate) fn new(file_id: FileId, node: SyntaxNodeRef) -> SyntaxPtr {
-        let local = LocalSyntaxPtr::new(node);
-        SyntaxPtr { file_id, local }
-    }
-    pub(crate) fn file_id(self) -> FileId {
-        self.file_id
-    }
-}
-/// A pionter to a syntax node inside a file.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct LocalSyntaxPtr {
-    range: TextRange,
-    kind: SyntaxKind,
-}
-impl LocalSyntaxPtr {
-    pub(crate) fn new(node: SyntaxNodeRef) -> LocalSyntaxPtr {
-        LocalSyntaxPtr {
-            range: node.range(),
-            kind: node.kind(),
-        }
-    }
-    pub(crate) fn resolve(self, file: &SourceFileNode) -> SyntaxNode {
-        let mut curr = file.syntax();
-        loop {
-            if curr.range() == self.range && curr.kind() == self.kind {
-                return curr.owned();
-            }
-            curr = curr
-                .children()
-                .find(|it| self.range.is_subrange(&it.range()))
-                .unwrap_or_else(|| panic!("can't resolve local ptr to SyntaxNode: {:?}", self))
-        }
-    }
-    pub(crate) fn into_global(self, file_id: FileId) -> SyntaxPtr {
-        SyntaxPtr {
-            file_id,
-            local: self,
-        }
-    }
-    // Seems unfortunate to expose
-    pub(crate) fn range(self) -> TextRange {
-        self.range
-    }
-}
-#[test]
-fn test_local_syntax_ptr() {
-    use ra_syntax::{ast, AstNode};
-    let file = SourceFileNode::parse("struct Foo { f: u32, }");
-    let field = file
-        .syntax()
-        .descendants()
-        .find_map(ast::NamedFieldDef::cast)
-        .unwrap();
-    let ptr = LocalSyntaxPtr::new(field.syntax());
-    let field_syntax = ptr.resolve(&file);
-    assert_eq!(field.syntax(), field_syntax);
-}
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
index 719c166b5..fbe89f444 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/tests.rs
@@ -10,10 +10,10 @@ use test_utils::assert_eq_dbg;
 use ra_analysis::{
    mock_analysis::{analysis_and_position, single_file, single_file_with_position, MockAnalysis},
-    AnalysisChange, CrateGraph, FileId, FnDescriptor,
+    AnalysisChange, CrateGraph, FileId, FnSignatureInfo,
 };
-fn get_signature(text: &str) -> (FnDescriptor, Option<usize>) {
+fn get_signature(text: &str) -> (FnSignatureInfo, Option<usize>) {
    let (analysis, position) = single_file_with_position(text);
    analysis.resolve_callable(position).unwrap().unwrap()
 }
@@ -126,7 +126,7 @@ fn test_resolve_crate_root() {
    let mut host = mock.analysis_host();
    assert!(host.analysis().crate_for(mod_file).unwrap().is_empty());
-    let mut crate_graph = CrateGraph::new();
+    let mut crate_graph = CrateGraph::default();
    let crate_id = crate_graph.add_crate_root(root_file);
    let mut change = AnalysisChange::new();
    change.set_crate_graph(crate_graph);
@@ -447,8 +447,8 @@ fn test_complete_crate_path() {
    );
    let completions = analysis.completions(position).unwrap().unwrap();
    assert_eq_dbg(
-        r#"[CompletionItem { label: "foo", lookup: None, snippet: None },
+        r#"[CompletionItem { label: "Spam", lookup: None, snippet: None },
-            CompletionItem { label: "Spam", lookup: None, snippet: None }]"#,
+            CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
        &completions,
    );
 }
@@ -466,8 +466,8 @@ fn test_complete_crate_path_with_braces() {
    );
    let completions = analysis.completions(position).unwrap().unwrap();
    assert_eq_dbg(
-        r#"[CompletionItem { label: "foo", lookup: None, snippet: None },
+        r#"[CompletionItem { label: "Spam", lookup: None, snippet: None },
-            CompletionItem { label: "Spam", lookup: None, snippet: None }]"#,
+            CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
        &completions,
    );
 }
diff --git a/crates/ra_db/Cargo.toml b/crates/ra_db/Cargo.toml
new file mode 100644
index 000000000..f316c0ab2
--- /dev/null
+++ b/crates/ra_db/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+edition = "2018"
+name = "ra_db"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+[dependencies]
+relative-path = "0.4.0"
+salsa = "0.8.0"
+rustc-hash = "1.0"
+parking_lot = "0.6.4"
+ra_syntax = { path = "../ra_syntax" }
+ra_editor = { path = "../ra_editor" }
+test_utils = { path = "../test_utils" }
diff --git a/crates/ra_db/src/file_resolver.rs b/crates/ra_db/src/file_resolver.rs
new file mode 100644
index 000000000..f849ac752
--- /dev/null
+++ b/crates/ra_db/src/file_resolver.rs
@@ -0,0 +1,76 @@
+use std::{
+    sync::Arc,
+    hash::{Hash, Hasher},
+    fmt,
+};
+use relative_path::RelativePath;
+use crate::input::FileId;
+pub trait FileResolver: fmt::Debug + Send + Sync + 'static {
+    fn file_stem(&self, file_id: FileId) -> String;
+    fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId>;
+    fn debug_path(&self, _1file_id: FileId) -> Option<std::path::PathBuf> {
+        None
+    }
+}
+#[derive(Clone, Debug)]
+pub struct FileResolverImp {
+    inner: Arc<FileResolver>,
+}
+impl PartialEq for FileResolverImp {
+    fn eq(&self, other: &FileResolverImp) -> bool {
+        self.inner() == other.inner()
+    }
+}
+impl Eq for FileResolverImp {}
+impl Hash for FileResolverImp {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        self.inner().hash(hasher);
+    }
+}
+impl FileResolverImp {
+    pub fn new(inner: Arc<FileResolver>) -> FileResolverImp {
+        FileResolverImp { inner }
+    }
+    pub fn file_stem(&self, file_id: FileId) -> String {
+        self.inner.file_stem(file_id)
+    }
+    pub fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId> {
+        self.inner.resolve(file_id, path)
+    }
+    pub fn debug_path(&self, file_id: FileId) -> Option<std::path::PathBuf> {
+        self.inner.debug_path(file_id)
+    }
+    fn inner(&self) -> *const FileResolver {
+        &*self.inner
+    }
+}
+impl Default for FileResolverImp {
+    fn default() -> FileResolverImp {
+        #[derive(Debug)]
+        struct DummyResolver;
+        impl FileResolver for DummyResolver {
+            fn file_stem(&self, _file_: FileId) -> String {
+                panic!("file resolver not set")
+            }
+            fn resolve(
+                &self,
+                _file_id: FileId,
+                _path: &::relative_path::RelativePath,
+            ) -> Option<FileId> {
+                panic!("file resolver not set")
+            }
+        }
+        FileResolverImp {
+            inner: Arc::new(DummyResolver),
+        }
+    }
+}
diff --git a/crates/ra_analysis/src/input.rs b/crates/ra_db/src/input.rs
index ba8a17fd5..9101ac7a8 100644
--- a/crates/ra_analysis/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -1,11 +1,10 @@
-use std::{fmt, sync::Arc};
+use std::sync::Arc;
-use relative_path::RelativePath;
 use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
 use salsa;
-use crate::{symbol_index::SymbolIndex, FileResolverImp};
+use crate::file_resolver::FileResolverImp;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct FileId(pub u32);
@@ -19,8 +18,8 @@ pub struct CrateGraph {
 }
 impl CrateGraph {
-    pub fn new() -> CrateGraph {
+    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
-        CrateGraph::default()
+        self.crate_roots[&crate_id]
    }
    pub fn add_crate_root(&mut self, file_id: FileId) -> CrateId {
        let crate_id = CrateId(self.crate_roots.len() as u32);
@@ -28,15 +27,17 @@ impl CrateGraph {
        assert!(prev.is_none());
        crate_id
    }
-}
+    pub fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
+        let (&crate_id, _) = self
-pub trait FileResolver: fmt::Debug + Send + Sync + 'static {
+            .crate_roots
-    fn file_stem(&self, file_id: FileId) -> String;
+            .iter()
-    fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId>;
+            .find(|(_crate_id, &root_id)| root_id == file_id)?;
+        Some(crate_id)
+    }
 }
 salsa::query_group! {
-    pub(crate) trait FilesDatabase: salsa::Database {
+    pub trait FilesDatabase: salsa::Database {
        fn file_text(file_id: FileId) -> Arc<String> {
            type FileTextQuery;
            storage input;
@@ -53,10 +54,6 @@ salsa::query_group! {
            type LibrariesQuery;
            storage input;
        }
-        fn library_symbols(id: SourceRootId) -> Arc<SymbolIndex> {
-            type LibrarySymbolsQuery;
-            storage input;
-        }
        fn crate_graph() -> Arc<CrateGraph> {
            type CrateGraphQuery;
            storage input;
@@ -65,12 +62,12 @@ salsa::query_group! {
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub(crate) struct SourceRootId(pub(crate) u32);
+pub struct SourceRootId(pub u32);
 #[derive(Default, Clone, Debug, PartialEq, Eq)]
-pub(crate) struct SourceRoot {
+pub struct SourceRoot {
-    pub(crate) file_resolver: FileResolverImp,
+    pub file_resolver: FileResolverImp,
-    pub(crate) files: FxHashSet<FileId>,
+    pub files: FxHashSet<FileId>,
 }
-pub(crate) const WORKSPACE: SourceRootId = SourceRootId(0);
+pub const WORKSPACE: SourceRootId = SourceRootId(0);
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
new file mode 100644
index 000000000..53805aada
--- /dev/null
+++ b/crates/ra_db/src/lib.rs
@@ -0,0 +1,83 @@
+//! ra_db defines basic database traits. Concrete DB is defined by ra_analysis.
+mod syntax_ptr;
+mod file_resolver;
+mod input;
+mod loc2id;
+pub mod mock;
+use std::sync::Arc;
+use ra_editor::LineIndex;
+use ra_syntax::{TextUnit, SourceFileNode};
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Canceled;
+pub type Cancelable<T> = Result<T, Canceled>;
+impl std::fmt::Display for Canceled {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fmt.write_str("Canceled")
+    }
+}
+impl std::error::Error for Canceled {}
+pub use crate::{
+    syntax_ptr::LocalSyntaxPtr,
+    file_resolver::{FileResolver, FileResolverImp},
+    input::{
+        FilesDatabase, FileId, CrateId, SourceRoot, SourceRootId, CrateGraph, WORKSPACE,
+        FileTextQuery, FileSourceRootQuery, SourceRootQuery, LibrariesQuery, CrateGraphQuery,
+    },
+    loc2id::{LocationIntener, NumericId},
+};
+#[macro_export]
+macro_rules! impl_numeric_id {
+    ($id:ident) => {
+        impl $crate::NumericId for $id {
+            fn from_u32(id: u32) -> Self {
+                $id(id)
+            }
+            fn to_u32(self) -> u32 {
+                self.0
+            }
+        }
+    };
+}
+pub trait BaseDatabase: salsa::Database {
+    fn check_canceled(&self) -> Cancelable<()> {
+        if self.salsa_runtime().is_current_revision_canceled() {
+            Err(Canceled)
+        } else {
+            Ok(())
+        }
+    }
+}
+salsa::query_group! {
+    pub trait SyntaxDatabase: crate::input::FilesDatabase + BaseDatabase {
+        fn source_file(file_id: FileId) -> SourceFileNode {
+            type SourceFileQuery;
+        }
+        fn file_lines(file_id: FileId) -> Arc<LineIndex> {
+            type FileLinesQuery;
+        }
+    }
+}
+fn source_file(db: &impl SyntaxDatabase, file_id: FileId) -> SourceFileNode {
+    let text = db.file_text(file_id);
+    SourceFileNode::parse(&*text)
+}
+fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
+    let text = db.file_text(file_id);
+    Arc::new(LineIndex::new(&*text))
+}
+#[derive(Clone, Copy, Debug)]
+pub struct FilePosition {
+    pub file_id: FileId,
+    pub offset: TextUnit,
+}
diff --git a/crates/ra_db/src/loc2id.rs b/crates/ra_db/src/loc2id.rs
new file mode 100644
index 000000000..69ba43d0f
--- /dev/null
+++ b/crates/ra_db/src/loc2id.rs
@@ -0,0 +1,100 @@
+use parking_lot::Mutex;
+use std::hash::Hash;
+use rustc_hash::FxHashMap;
+/// There are two principle ways to refer to things:
+///   - by their locatinon (module in foo/bar/baz.rs at line 42)
+///   - by their numeric id (module `ModuleId(42)`)
+///
+/// The first one is more powerful (you can actually find the thing in question
+/// by id), but the second one is so much more compact.
+///
+/// `Loc2IdMap` allows us to have a cake an eat it as well: by maintaining a
+/// bidirectional mapping between positional and numeric ids, we can use compact
+/// representation wich still allows us to get the actual item
+#[derive(Debug)]
+struct Loc2IdMap<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    loc2id: FxHashMap<LOC, ID>,
+    id2loc: FxHashMap<ID, LOC>,
+}
+impl<LOC, ID> Default for Loc2IdMap<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    fn default() -> Self {
+        Loc2IdMap {
+            loc2id: FxHashMap::default(),
+            id2loc: FxHashMap::default(),
+        }
+    }
+}
+impl<LOC, ID> Loc2IdMap<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    pub fn loc2id(&mut self, loc: &LOC) -> ID {
+        match self.loc2id.get(loc) {
+            Some(id) => return id.clone(),
+            None => (),
+        }
+        let id = self.loc2id.len();
+        assert!(id < u32::max_value() as usize);
+        let id = ID::from_u32(id as u32);
+        self.loc2id.insert(loc.clone(), id.clone());
+        self.id2loc.insert(id.clone(), loc.clone());
+        id
+    }
+    pub fn id2loc(&self, id: ID) -> LOC {
+        self.id2loc[&id].clone()
+    }
+}
+pub trait NumericId: Clone + Eq + Hash {
+    fn from_u32(id: u32) -> Self;
+    fn to_u32(self) -> u32;
+}
+#[derive(Debug)]
+pub struct LocationIntener<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    map: Mutex<Loc2IdMap<LOC, ID>>,
+}
+impl<LOC, ID> Default for LocationIntener<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    fn default() -> Self {
+        LocationIntener {
+            map: Default::default(),
+        }
+    }
+}
+impl<LOC, ID> LocationIntener<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    pub fn loc2id(&self, loc: &LOC) -> ID {
+        self.map.lock().loc2id(loc)
+    }
+    pub fn id2loc(&self, id: ID) -> LOC {
+        self.map.lock().id2loc(id)
+    }
+}
diff --git a/crates/ra_db/src/mock.rs b/crates/ra_db/src/mock.rs
new file mode 100644
index 000000000..2840f9655
--- /dev/null
+++ b/crates/ra_db/src/mock.rs
@@ -0,0 +1,51 @@
+use std::sync::Arc;
+use rustc_hash::FxHashSet;
+use relative_path::{RelativePath, RelativePathBuf};
+use crate::{FileId, FileResolver, SourceRoot, FileResolverImp};
+#[derive(Default, Debug)]
+pub struct FileMap(Vec<(FileId, RelativePathBuf)>);
+impl FileMap {
+    pub fn add(&mut self, path: RelativePathBuf) -> FileId {
+        let file_id = FileId((self.0.len() + 1) as u32);
+        self.0.push((file_id, path));
+        file_id
+    }
+    pub fn into_source_root(self) -> SourceRoot {
+        let files = self.files();
+        let file_resolver = FileResolverImp::new(Arc::new(self));
+        SourceRoot {
+            file_resolver,
+            files,
+        }
+    }
+    pub fn files(&self) -> FxHashSet<FileId> {
+        self.iter().map(|(id, _)| id).collect()
+    }
+    fn iter<'a>(&'a self) -> impl Iterator<Item = (FileId, &'a RelativePath)> + 'a {
+        self.0
+            .iter()
+            .map(|(id, path)| (*id, path.as_relative_path()))
+    }
+    fn path(&self, id: FileId) -> &RelativePath {
+        self.iter().find(|&(it, _)| it == id).unwrap().1
+    }
+}
+impl FileResolver for FileMap {
+    fn file_stem(&self, id: FileId) -> String {
+        self.path(id).file_stem().unwrap().to_string()
+    }
+    fn resolve(&self, id: FileId, rel: &RelativePath) -> Option<FileId> {
+        let path = self.path(id).join(rel).normalize();
+        let id = self.iter().find(|&(_, p)| path == p)?.0;
+        Some(id)
+    }
+}
diff --git a/crates/ra_db/src/syntax_ptr.rs b/crates/ra_db/src/syntax_ptr.rs
new file mode 100644
index 000000000..dac94dd36
--- /dev/null
+++ b/crates/ra_db/src/syntax_ptr.rs
@@ -0,0 +1,48 @@
+use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, TextRange};
+/// A pionter to a syntax node inside a file.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct LocalSyntaxPtr {
+    range: TextRange,
+    kind: SyntaxKind,
+}
+impl LocalSyntaxPtr {
+    pub fn new(node: SyntaxNodeRef) -> LocalSyntaxPtr {
+        LocalSyntaxPtr {
+            range: node.range(),
+            kind: node.kind(),
+        }
+    }
+    pub fn resolve(self, file: &SourceFileNode) -> SyntaxNode {
+        let mut curr = file.syntax();
+        loop {
+            if curr.range() == self.range && curr.kind() == self.kind {
+                return curr.owned();
+            }
+            curr = curr
+                .children()
+                .find(|it| self.range.is_subrange(&it.range()))
+                .unwrap_or_else(|| panic!("can't resolve local ptr to SyntaxNode: {:?}", self))
+        }
+    }
+    pub fn range(self) -> TextRange {
+        self.range
+    }
+}
+#[test]
+fn test_local_syntax_ptr() {
+    use ra_syntax::{ast, AstNode};
+    let file = SourceFileNode::parse("struct Foo { f: u32, }");
+    let field = file
+        .syntax()
+        .descendants()
+        .find_map(ast::NamedFieldDef::cast)
+        .unwrap();
+    let ptr = LocalSyntaxPtr::new(field.syntax());
+    let field_syntax = ptr.resolve(&file);
+    assert_eq!(field.syntax(), field_syntax);
+}
diff --git a/crates/ra_editor/src/code_actions.rs b/crates/ra_editor/src/code_actions.rs
index bc0e120d3..6979251d1 100644
--- a/crates/ra_editor/src/code_actions.rs
+++ b/crates/ra_editor/src/code_actions.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
    algo::{find_covering_node, find_leaf_at_offset},
    ast::{self, AstNode, AttrsOwner, NameOwner, TypeParamsOwner},
    Direction, SourceFileNode,
-    SyntaxKind::{COMMA, WHITESPACE},
+    SyntaxKind::{COMMA, WHITESPACE, COMMENT},
    SyntaxNodeRef, TextRange, TextUnit,
 };
@@ -41,7 +41,8 @@ pub fn add_derive<'a>(
    offset: TextUnit,
 ) -> Option<impl FnOnce() -> LocalEdit + 'a> {
    let nominal = find_node_at_offset::<ast::NominalDef>(file.syntax(), offset)?;
-    Some(move || {
+    let node_start = derive_insertion_offset(nominal)?;
+    return Some(move || {
        let derive_attr = nominal
            .attrs()
            .filter_map(|x| x.as_call())
@@ -51,7 +52,6 @@ pub fn add_derive<'a>(
        let mut edit = EditBuilder::new();
        let offset = match derive_attr {
            None => {
-                let node_start = nominal.syntax().range().start();
                edit.insert(node_start, "#[derive()]\n".to_string());
                node_start + TextUnit::of_str("#[derive(")
            }
@@ -61,7 +61,16 @@ pub fn add_derive<'a>(
            edit: edit.finish(),
            cursor_position: Some(offset),
        }
-    })
+    });
+    // Insert `derive` after doc comments.
+    fn derive_insertion_offset(nominal: ast::NominalDef) -> Option<TextUnit> {
+        let non_ws_child = nominal
+            .syntax()
+            .children()
+            .find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
+        Some(non_ws_child.range().start())
+    }
 }
 pub fn add_impl<'a>(
@@ -186,7 +195,7 @@ mod tests {
    }
    #[test]
-    fn test_add_derive() {
+    fn add_derive_new() {
        check_action(
            "struct Foo { a: i32, <|>}",
            "#[derive(<|>)]\nstruct Foo { a: i32, }",
@@ -197,6 +206,10 @@ mod tests {
            "#[derive(<|>)]\nstruct Foo {  a: i32, }",
            |file, off| add_derive(file, off).map(|f| f()),
        );
+    }
+    #[test]
+    fn add_derive_existing() {
        check_action(
            "#[derive(Clone)]\nstruct Foo { a: i32<|>, }",
            "#[derive(Clone<|>)]\nstruct Foo { a: i32, }",
@@ -205,6 +218,24 @@ mod tests {
    }
    #[test]
+    fn add_derive_new_with_doc_comment() {
+        check_action(
+            "
+/// `Foo` is a pretty important struct.
+/// It does stuff.
+struct Foo { a: i32<|>, }
+            ",
+            "
+/// `Foo` is a pretty important struct.
+/// It does stuff.
+#[derive(<|>)]
+struct Foo { a: i32, }
+            ",
+            |file, off| add_derive(file, off).map(|f| f()),
+        );
+    }
+    #[test]
    fn test_add_impl() {
        check_action(
            "struct Foo {<|>}\n",
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
index ff4e8303d..c6b116159 100644
--- a/crates/ra_editor/src/lib.rs
+++ b/crates/ra_editor/src/lib.rs
@@ -148,12 +148,7 @@ pub fn find_node_at_offset<'a, N: AstNode<'a>>(
    syntax: SyntaxNodeRef<'a>,
    offset: TextUnit,
 ) -> Option<N> {
-    let leaves = find_leaf_at_offset(syntax, offset);
+    find_leaf_at_offset(syntax, offset).find_map(|leaf| leaf.ancestors().find_map(N::cast))
-    let leaf = leaves
-        .clone()
-        .find(|leaf| !leaf.kind().is_trivia())
-        .or_else(|| leaves.right_biased())?;
-    leaf.ancestors().filter_map(N::cast).next()
 }
 #[cfg(test)]
diff --git a/crates/ra_editor/src/line_index.rs b/crates/ra_editor/src/line_index.rs
index 9abbb0d09..aab7e4081 100644
--- a/crates/ra_editor/src/line_index.rs
+++ b/crates/ra_editor/src/line_index.rs
@@ -1,43 +1,124 @@
 use crate::TextUnit;
+use rustc_hash::FxHashMap;
 use superslice::Ext;
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct LineIndex {
    newlines: Vec<TextUnit>,
+    utf16_lines: FxHashMap<u32, Vec<Utf16Char>>,
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct LineCol {
    pub line: u32,
-    pub col: TextUnit,
+    pub col_utf16: u32,
+}
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+struct Utf16Char {
+    start: TextUnit,
+    end: TextUnit,
+}
+impl Utf16Char {
+    fn len(&self) -> TextUnit {
+        self.end - self.start
+    }
 }
 impl LineIndex {
    pub fn new(text: &str) -> LineIndex {
+        let mut utf16_lines = FxHashMap::default();
+        let mut utf16_chars = Vec::new();
        let mut newlines = vec![0.into()];
-        let mut curr = 0.into();
+        let mut curr_row = 0.into();
+        let mut curr_col = 0.into();
+        let mut line = 0;
        for c in text.chars() {
-            curr += TextUnit::of_char(c);
+            curr_row += TextUnit::of_char(c);
            if c == '\n' {
-                newlines.push(curr);
+                newlines.push(curr_row);
+                // Save any utf-16 characters seen in the previous line
+                if utf16_chars.len() > 0 {
+                    utf16_lines.insert(line, utf16_chars);
+                    utf16_chars = Vec::new();
+                }
+                // Prepare for processing the next line
+                curr_col = 0.into();
+                line += 1;
+                continue;
            }
+            let char_len = TextUnit::of_char(c);
+            if char_len.to_usize() > 1 {
+                utf16_chars.push(Utf16Char {
+                    start: curr_col,
+                    end: curr_col + char_len,
+                });
+            }
+            curr_col += char_len;
+        }
+        LineIndex {
+            newlines,
+            utf16_lines,
        }
-        LineIndex { newlines }
    }
    pub fn line_col(&self, offset: TextUnit) -> LineCol {
        let line = self.newlines.upper_bound(&offset) - 1;
        let line_start_offset = self.newlines[line];
        let col = offset - line_start_offset;
        LineCol {
            line: line as u32,
-            col,
+            col_utf16: self.utf8_to_utf16_col(line as u32, col) as u32,
        }
    }
    pub fn offset(&self, line_col: LineCol) -> TextUnit {
        //TODO: return Result
-        self.newlines[line_col.line as usize] + line_col.col
+        let col = self.utf16_to_utf8_col(line_col.line, line_col.col_utf16);
+        self.newlines[line_col.line as usize] + col
+    }
+    fn utf8_to_utf16_col(&self, line: u32, mut col: TextUnit) -> usize {
+        if let Some(utf16_chars) = self.utf16_lines.get(&line) {
+            let mut correction = TextUnit::from_usize(0);
+            for c in utf16_chars {
+                if col >= c.end {
+                    correction += c.len() - TextUnit::from_usize(1);
+                } else {
+                    // From here on, all utf16 characters come *after* the character we are mapping,
+                    // so we don't need to take them into account
+                    break;
+                }
+            }
+            col -= correction;
+        }
+        col.to_usize()
+    }
+    fn utf16_to_utf8_col(&self, line: u32, col: u32) -> TextUnit {
+        let mut col: TextUnit = col.into();
+        if let Some(utf16_chars) = self.utf16_lines.get(&line) {
+            for c in utf16_chars {
+                if col >= c.start {
+                    col += c.len() - TextUnit::from_usize(1);
+                } else {
+                    // From here on, all utf16 characters come *after* the character we are mapping,
+                    // so we don't need to take them into account
+                    break;
+                }
+            }
+        }
+        col
    }
 }
@@ -49,63 +130,63 @@ fn test_line_index() {
        index.line_col(0.into()),
        LineCol {
            line: 0,
-            col: 0.into()
+            col_utf16: 0
        }
    );
    assert_eq!(
        index.line_col(1.into()),
        LineCol {
            line: 0,
-            col: 1.into()
+            col_utf16: 1
        }
    );
    assert_eq!(
        index.line_col(5.into()),
        LineCol {
            line: 0,
-            col: 5.into()
+            col_utf16: 5
        }
    );
    assert_eq!(
        index.line_col(6.into()),
        LineCol {
            line: 1,
-            col: 0.into()
+            col_utf16: 0
        }
    );
    assert_eq!(
        index.line_col(7.into()),
        LineCol {
            line: 1,
-            col: 1.into()
+            col_utf16: 1
        }
    );
    assert_eq!(
        index.line_col(8.into()),
        LineCol {
            line: 1,
-            col: 2.into()
+            col_utf16: 2
        }
    );
    assert_eq!(
        index.line_col(10.into()),
        LineCol {
            line: 1,
-            col: 4.into()
+            col_utf16: 4
        }
    );
    assert_eq!(
        index.line_col(11.into()),
        LineCol {
            line: 1,
-            col: 5.into()
+            col_utf16: 5
        }
    );
    assert_eq!(
        index.line_col(12.into()),
        LineCol {
            line: 1,
-            col: 6.into()
+            col_utf16: 6
        }
    );
@@ -115,35 +196,129 @@ fn test_line_index() {
        index.line_col(0.into()),
        LineCol {
            line: 0,
-            col: 0.into()
+            col_utf16: 0
        }
    );
    assert_eq!(
        index.line_col(1.into()),
        LineCol {
            line: 1,
-            col: 0.into()
+            col_utf16: 0
        }
    );
    assert_eq!(
        index.line_col(2.into()),
        LineCol {
            line: 1,
-            col: 1.into()
+            col_utf16: 1
        }
    );
    assert_eq!(
        index.line_col(6.into()),
        LineCol {
            line: 1,
-            col: 5.into()
+            col_utf16: 5
        }
    );
    assert_eq!(
        index.line_col(7.into()),
        LineCol {
            line: 2,
-            col: 0.into()
+            col_utf16: 0
        }
    );
 }
+#[cfg(test)]
+mod test_utf8_utf16_conv {
+    use super::*;
+    #[test]
+    fn test_char_len() {
+        assert_eq!('メ'.len_utf8(), 3);
+        assert_eq!('メ'.len_utf16(), 1);
+    }
+    #[test]
+    fn test_empty_index() {
+        let col_index = LineIndex::new(
+            "
+const C: char = 'x';
+",
+        );
+        assert_eq!(col_index.utf16_lines.len(), 0);
+    }
+    #[test]
+    fn test_single_char() {
+        let col_index = LineIndex::new(
+            "
+const C: char = 'メ';
+",
+        );
+        assert_eq!(col_index.utf16_lines.len(), 1);
+        assert_eq!(col_index.utf16_lines[&1].len(), 1);
+        assert_eq!(
+            col_index.utf16_lines[&1][0],
+            Utf16Char {
+                start: 17.into(),
+                end: 20.into()
+            }
+        );
+        // UTF-8 to UTF-16, no changes
+        assert_eq!(col_index.utf8_to_utf16_col(1, 15.into()), 15);
+        // UTF-8 to UTF-16
+        assert_eq!(col_index.utf8_to_utf16_col(1, 22.into()), 20);
+        // UTF-16 to UTF-8, no changes
+        assert_eq!(col_index.utf16_to_utf8_col(1, 15), TextUnit::from(15));
+        // UTF-16 to UTF-8
+        assert_eq!(col_index.utf16_to_utf8_col(1, 19), TextUnit::from(21));
+    }
+    #[test]
+    fn test_string() {
+        let col_index = LineIndex::new(
+            "
+const C: char = \"メ メ\";
+",
+        );
+        assert_eq!(col_index.utf16_lines.len(), 1);
+        assert_eq!(col_index.utf16_lines[&1].len(), 2);
+        assert_eq!(
+            col_index.utf16_lines[&1][0],
+            Utf16Char {
+                start: 17.into(),
+                end: 20.into()
+            }
+        );
+        assert_eq!(
+            col_index.utf16_lines[&1][1],
+            Utf16Char {
+                start: 21.into(),
+                end: 24.into()
+            }
+        );
+        // UTF-8 to UTF-16
+        assert_eq!(col_index.utf8_to_utf16_col(1, 15.into()), 15);
+        assert_eq!(col_index.utf8_to_utf16_col(1, 21.into()), 19);
+        assert_eq!(col_index.utf8_to_utf16_col(1, 25.into()), 21);
+        assert!(col_index.utf8_to_utf16_col(2, 15.into()) == 15);
+        // UTF-16 to UTF-8
+        assert_eq!(col_index.utf16_to_utf8_col(1, 15), TextUnit::from_usize(15));
+        assert_eq!(col_index.utf16_to_utf8_col(1, 18), TextUnit::from_usize(20));
+        assert_eq!(col_index.utf16_to_utf8_col(1, 19), TextUnit::from_usize(23));
+        assert_eq!(col_index.utf16_to_utf8_col(2, 15), TextUnit::from_usize(15));
+    }
+}
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
new file mode 100644
index 000000000..1b9e148b2
--- /dev/null
+++ b/crates/ra_hir/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+edition = "2018"
+name = "ra_hir"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+[dependencies]
+log = "0.4.5"
+relative-path = "0.4.0"
+salsa = "0.8.0"
+rustc-hash = "1.0"
+parking_lot = "0.6.4"
+id-arena = "2.0"
+ra_syntax = { path = "../ra_syntax" }
+ra_editor = { path = "../ra_editor" }
+ra_db = { path = "../ra_db" }
+test_utils = { path = "../test_utils" }
diff --git a/crates/ra_hir/src/arena.rs b/crates/ra_hir/src/arena.rs
new file mode 100644
index 000000000..d4f9d9cb9
--- /dev/null
+++ b/crates/ra_hir/src/arena.rs
@@ -0,0 +1,66 @@
+//! A simple id-based arena, similar to https://github.com/fitzgen/id-arena.
+//! We use our own version for more compact id's and to allow inherent impls
+//! on Ids.
+use std::{
+    fmt,
+    hash::{Hash, Hasher},
+    marker::PhantomData,
+};
+pub struct Id<T> {
+    idx: u32,
+    _ty: PhantomData<fn() -> T>,
+}
+impl<T> fmt::Debug for Id<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_tuple("Id").field(&self.idx).finish()
+    }
+}
+impl<T> Copy for Id<T> {}
+impl<T> Clone for Id<T> {
+    fn clone(&self) -> Id<T> {
+        *self
+    }
+}
+impl<T> PartialEq for Id<T> {
+    fn eq(&self, other: &Id<T>) -> bool {
+        self.idx == other.idx
+    }
+}
+impl<T> Eq for Id<T> {}
+impl<T> Hash for Id<T> {
+    fn hash<H: Hasher>(&self, h: &mut H) {
+        self.idx.hash(h);
+    }
+}
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct ArenaBehavior<T> {
+    _ty: PhantomData<T>,
+}
+impl<T> id_arena::ArenaBehavior for ArenaBehavior<T> {
+    type Id = Id<T>;
+    fn new_arena_id() -> u32 {
+        0
+    }
+    fn new_id(_arena_id: u32, index: usize) -> Id<T> {
+        Id {
+            idx: index as u32,
+            _ty: PhantomData,
+        }
+    }
+    fn index(id: Id<T>) -> usize {
+        id.idx as usize
+    }
+    fn arena_id(_id: Id<T>) -> u32 {
+        0
+    }
+}
+pub(crate) type Arena<T> = id_arena::Arena<T, ArenaBehavior<T>>;
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
new file mode 100644
index 000000000..2f01bae6d
--- /dev/null
+++ b/crates/ra_hir/src/db.rs
@@ -0,0 +1,66 @@
+use std::sync::Arc;
+use ra_syntax::{
+    SyntaxNode,
+    ast::FnDefNode,
+};
+use ra_db::{SourceRootId, LocationIntener, SyntaxDatabase, FileId, Cancelable};
+use crate::{
+    DefLoc, DefId, FnId,
+    SourceFileItems, SourceItemId,
+    query_definitions,
+    FnScopes,
+    module::{ModuleId, ModuleTree, ModuleSource,
+    nameres::{ItemMap, InputModuleItems}},
+};
+salsa::query_group! {
+pub trait HirDatabase: SyntaxDatabase
+    + AsRef<LocationIntener<DefLoc, DefId>>
+    + AsRef<LocationIntener<SourceItemId, FnId>>
+{
+    fn fn_scopes(fn_id: FnId) -> Arc<FnScopes> {
+        type FnScopesQuery;
+        use fn query_definitions::fn_scopes;
+    }
+    fn fn_syntax(fn_id: FnId) -> FnDefNode {
+        type FnSyntaxQuery;
+        // Don't retain syntax trees in memory
+        storage dependencies;
+        use fn query_definitions::fn_syntax;
+    }
+    fn file_items(file_id: FileId) -> Arc<SourceFileItems> {
+        type SourceFileItemsQuery;
+        storage dependencies;
+        use fn query_definitions::file_items;
+    }
+    fn file_item(source_item_id: SourceItemId) -> SyntaxNode {
+        type FileItemQuery;
+        storage dependencies;
+        use fn query_definitions::file_item;
+    }
+    fn submodules(source: ModuleSource) -> Cancelable<Arc<Vec<crate::module::imp::Submodule>>> {
+        type SubmodulesQuery;
+        use fn query_definitions::submodules;
+    }
+    fn input_module_items(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<InputModuleItems>> {
+        type InputModuleItemsQuery;
+        use fn query_definitions::input_module_items;
+    }
+    fn item_map(source_root_id: SourceRootId) -> Cancelable<Arc<ItemMap>> {
+        type ItemMapQuery;
+        use fn query_definitions::item_map;
+    }
+    fn module_tree(source_root_id: SourceRootId) -> Cancelable<Arc<ModuleTree>> {
+        type ModuleTreeQuery;
+        use fn crate::module::imp::module_tree;
+    }
+}
+}
diff --git a/crates/ra_analysis/src/descriptors/function/mod.rs b/crates/ra_hir/src/function/mod.rs
index d5db28a64..c8af2e54f 100644
--- a/crates/ra_analysis/src/descriptors/function/mod.rs
+++ b/crates/ra_hir/src/function/mod.rs
@@ -1,29 +1,83 @@
-pub(super) mod imp;
 mod scope;
-use std::cmp::{max, min};
+use std::{
+    cmp::{max, min},
+    sync::Arc,
+};
 use ra_syntax::{
+    TextRange, TextUnit, SyntaxNodeRef,
    ast::{self, AstNode, DocCommentsOwner, NameOwner},
-    TextRange, TextUnit,
 };
+use ra_db::FileId;
-use crate::{syntax_ptr::SyntaxPtr, FileId};
+use crate::{
+    FnId, HirDatabase, SourceItemId,
-pub(crate) use self::scope::{resolve_local_name, FnScopes};
+};
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub use self::scope::FnScopes;
-pub(crate) struct FnId(SyntaxPtr);
 impl FnId {
-    pub(crate) fn new(file_id: FileId, fn_def: ast::FnDef) -> FnId {
+    pub fn get(db: &impl HirDatabase, file_id: FileId, fn_def: ast::FnDef) -> FnId {
-        let ptr = SyntaxPtr::new(file_id, fn_def.syntax());
+        let file_items = db.file_items(file_id);
-        FnId(ptr)
+        let item_id = file_items.id_of(fn_def.syntax());
+        let item_id = SourceItemId { file_id, item_id };
+        FnId::from_loc(db, &item_id)
+    }
+}
+pub struct Function {
+    fn_id: FnId,
+}
+impl Function {
+    pub fn guess_from_source(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        fn_def: ast::FnDef,
+    ) -> Function {
+        let fn_id = FnId::get(db, file_id, fn_def);
+        Function { fn_id }
+    }
+    pub fn guess_for_name_ref(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        name_ref: ast::NameRef,
+    ) -> Option<Function> {
+        Function::guess_for_node(db, file_id, name_ref.syntax())
+    }
+    pub fn guess_for_bind_pat(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        bind_pat: ast::BindPat,
+    ) -> Option<Function> {
+        Function::guess_for_node(db, file_id, bind_pat.syntax())
+    }
+    fn guess_for_node(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        node: SyntaxNodeRef,
+    ) -> Option<Function> {
+        let fn_def = node.ancestors().find_map(ast::FnDef::cast)?;
+        let res = Function::guess_from_source(db, file_id, fn_def);
+        Some(res)
+    }
+    pub fn scope(&self, db: &impl HirDatabase) -> Arc<FnScopes> {
+        db.fn_scopes(self.fn_id)
+    }
+    pub fn signature_info(&self, db: &impl HirDatabase) -> Option<FnSignatureInfo> {
+        let syntax = db.fn_syntax(self.fn_id);
+        FnSignatureInfo::new(syntax.borrowed())
    }
 }
 #[derive(Debug, Clone)]
-pub struct FnDescriptor {
+pub struct FnSignatureInfo {
    pub name: String,
    pub label: String,
    pub ret_type: Option<String>,
@@ -31,8 +85,8 @@ pub struct FnDescriptor {
    pub doc: Option<String>,
 }
-impl FnDescriptor {
+impl FnSignatureInfo {
-    pub fn new(node: ast::FnDef) -> Option<Self> {
+    fn new(node: ast::FnDef) -> Option<Self> {
        let name = node.name()?.text().to_string();
        let mut doc = None;
@@ -51,7 +105,7 @@ impl FnDescriptor {
            node.syntax().text().to_string()
        };
-        if let Some((comment_range, docs)) = FnDescriptor::extract_doc_comments(node) {
+        if let Some((comment_range, docs)) = FnSignatureInfo::extract_doc_comments(node) {
            let comment_range = comment_range
                .checked_sub(node.syntax().range().start())
                .unwrap();
@@ -83,10 +137,10 @@ impl FnDescriptor {
            }
        }
-        let params = FnDescriptor::param_list(node);
+        let params = FnSignatureInfo::param_list(node);
        let ret_type = node.ret_type().map(|r| r.syntax().text().to_string());
-        Some(FnDescriptor {
+        Some(FnSignatureInfo {
            name,
            ret_type,
            params,
diff --git a/crates/ra_analysis/src/descriptors/function/scope.rs b/crates/ra_hir/src/function/scope.rs
index bbe16947c..863453291 100644
--- a/crates/ra_analysis/src/descriptors/function/scope.rs
+++ b/crates/ra_hir/src/function/scope.rs
@@ -1,20 +1,22 @@
 use rustc_hash::{FxHashMap, FxHashSet};
 use ra_syntax::{
+    AstNode, SmolStr, SyntaxNodeRef, TextRange,
    algo::generate,
    ast::{self, ArgListOwner, LoopBodyOwner, NameOwner},
-    AstNode, SmolStr, SyntaxNodeRef,
 };
+use ra_db::LocalSyntaxPtr;
-use crate::syntax_ptr::LocalSyntaxPtr;
+use crate::{
+    arena::{Arena, Id},
+};
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) type ScopeId = Id<ScopeData>;
-pub(crate) struct ScopeId(u32);
 #[derive(Debug, PartialEq, Eq)]
 pub struct FnScopes {
-    pub(crate) self_param: Option<LocalSyntaxPtr>,
+    pub self_param: Option<LocalSyntaxPtr>,
-    scopes: Vec<ScopeData>,
+    scopes: Arena<ScopeData>,
    scope_for: FxHashMap<LocalSyntaxPtr, ScopeId>,
 }
@@ -25,19 +27,19 @@ pub struct ScopeEntry {
 }
 #[derive(Debug, PartialEq, Eq)]
-struct ScopeData {
+pub struct ScopeData {
    parent: Option<ScopeId>,
    entries: Vec<ScopeEntry>,
 }
 impl FnScopes {
-    pub(crate) fn new(fn_def: ast::FnDef) -> FnScopes {
+    pub fn new(fn_def: ast::FnDef) -> FnScopes {
        let mut scopes = FnScopes {
            self_param: fn_def
                .param_list()
                .and_then(|it| it.self_param())
                .map(|it| LocalSyntaxPtr::new(it.syntax())),
-            scopes: Vec::new(),
+            scopes: Arena::default(),
            scope_for: FxHashMap::default(),
        };
        let root = scopes.root_scope();
@@ -47,27 +49,56 @@ impl FnScopes {
        }
        scopes
    }
-    pub(crate) fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
+    pub fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
-        &self.get(scope).entries
+        &self.scopes[scope].entries
    }
    pub fn scope_chain<'a>(&'a self, node: SyntaxNodeRef) -> impl Iterator<Item = ScopeId> + 'a {
-        generate(self.scope_for(node), move |&scope| self.get(scope).parent)
+        generate(self.scope_for(node), move |&scope| {
+            self.scopes[scope].parent
+        })
+    }
+    pub fn resolve_local_name<'a>(&'a self, name_ref: ast::NameRef) -> Option<&'a ScopeEntry> {
+        let mut shadowed = FxHashSet::default();
+        let ret = self
+            .scope_chain(name_ref.syntax())
+            .flat_map(|scope| self.entries(scope).iter())
+            .filter(|entry| shadowed.insert(entry.name()))
+            .filter(|entry| entry.name() == &name_ref.text())
+            .nth(0);
+        ret
+    }
+    pub fn find_all_refs(&self, pat: ast::BindPat) -> Vec<ReferenceDescriptor> {
+        let fn_def = pat.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
+        let name_ptr = LocalSyntaxPtr::new(pat.syntax());
+        let refs: Vec<_> = fn_def
+            .syntax()
+            .descendants()
+            .filter_map(ast::NameRef::cast)
+            .filter(|name_ref| match self.resolve_local_name(*name_ref) {
+                None => false,
+                Some(entry) => entry.ptr() == name_ptr,
+            })
+            .map(|name_ref| ReferenceDescriptor {
+                name: name_ref.syntax().text().to_string(),
+                range: name_ref.syntax().range(),
+            })
+            .collect();
+        refs
    }
    fn root_scope(&mut self) -> ScopeId {
-        let res = ScopeId(self.scopes.len() as u32);
+        self.scopes.alloc(ScopeData {
-        self.scopes.push(ScopeData {
            parent: None,
            entries: vec![],
-        });
+        })
-        res
    }
    fn new_scope(&mut self, parent: ScopeId) -> ScopeId {
-        let res = ScopeId(self.scopes.len() as u32);
+        self.scopes.alloc(ScopeData {
-        self.scopes.push(ScopeData {
            parent: Some(parent),
            entries: vec![],
-        });
+        })
-        res
    }
    fn add_bindings(&mut self, scope: ScopeId, pat: ast::Pat) {
        let entries = pat
@@ -75,7 +106,7 @@ impl FnScopes {
            .descendants()
            .filter_map(ast::BindPat::cast)
            .filter_map(ScopeEntry::new);
-        self.get_mut(scope).entries.extend(entries);
+        self.scopes[scope].entries.extend(entries);
    }
    fn add_params_bindings(&mut self, scope: ScopeId, params: Option<ast::ParamList>) {
        params
@@ -93,12 +124,6 @@ impl FnScopes {
            .filter_map(|it| self.scope_for.get(&it).map(|&scope| scope))
            .next()
    }
-    fn get(&self, scope: ScopeId) -> &ScopeData {
-        &self.scopes[scope.0 as usize]
-    }
-    fn get_mut(&mut self, scope: ScopeId) -> &mut ScopeData {
-        &mut self.scopes[scope.0 as usize]
-    }
 }
 impl ScopeEntry {
@@ -110,10 +135,10 @@ impl ScopeEntry {
        };
        Some(res)
    }
-    pub(crate) fn name(&self) -> &SmolStr {
+    pub fn name(&self) -> &SmolStr {
        &self.name
    }
-    pub(crate) fn ptr(&self) -> LocalSyntaxPtr {
+    pub fn ptr(&self) -> LocalSyntaxPtr {
        self.ptr
    }
 }
@@ -255,18 +280,10 @@ fn compute_expr_scopes(expr: ast::Expr, scopes: &mut FnScopes, scope: ScopeId) {
    }
 }
-pub fn resolve_local_name<'a>(
+#[derive(Debug)]
-    name_ref: ast::NameRef,
+pub struct ReferenceDescriptor {
-    scopes: &'a FnScopes,
+    pub range: TextRange,
-) -> Option<&'a ScopeEntry> {
+    pub name: String,
-    let mut shadowed = FxHashSet::default();
-    let ret = scopes
-        .scope_chain(name_ref.syntax())
-        .flat_map(|scope| scopes.entries(scope).iter())
-        .filter(|entry| shadowed.insert(entry.name()))
-        .filter(|entry| entry.name() == &name_ref.text())
-        .nth(0);
-    ret
 }
 #[cfg(test)]
@@ -382,7 +399,7 @@ mod tests {
        let scopes = FnScopes::new(fn_def);
-        let local_name_entry = resolve_local_name(name_ref, &scopes).unwrap();
+        let local_name_entry = scopes.resolve_local_name(name_ref).unwrap();
        let local_name = local_name_entry.ptr().resolve(&file);
        let expected_name =
            find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into()).unwrap();
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
new file mode 100644
index 000000000..e7b6a81f4
--- /dev/null
+++ b/crates/ra_hir/src/lib.rs
@@ -0,0 +1,141 @@
+//! HIR (previsouly known as descriptors) provides a high-level OO acess to Rust
+//! code.
+//!
+//! The principal difference between HIR and syntax trees is that HIR is bound
+//! to a particular crate instance. That is, it has cfg flags and features
+//! applied. So, there relation between syntax and HIR is many-to-one.
+macro_rules! ctry {
+    ($expr:expr) => {
+        match $expr {
+            None => return Ok(None),
+            Some(it) => it,
+        }
+    };
+}
+pub mod db;
+#[cfg(test)]
+mod mock;
+mod query_definitions;
+mod function;
+mod module;
+mod path;
+mod arena;
+use std::ops::Index;
+use ra_syntax::{SyntaxNodeRef, SyntaxNode};
+use ra_db::{LocationIntener, SourceRootId, FileId, Cancelable};
+use crate::{
+    db::HirDatabase,
+    arena::{Arena, Id},
+};
+pub use self::{
+    path::{Path, PathKind},
+    module::{Module, ModuleId, Problem, nameres::ItemMap},
+    function::{Function, FnScopes},
+};
+pub use self::function::FnSignatureInfo;
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct FnId(u32);
+ra_db::impl_numeric_id!(FnId);
+impl FnId {
+    pub fn from_loc(
+        db: &impl AsRef<LocationIntener<SourceItemId, FnId>>,
+        loc: &SourceItemId,
+    ) -> FnId {
+        db.as_ref().loc2id(loc)
+    }
+    pub fn loc(self, db: &impl AsRef<LocationIntener<SourceItemId, FnId>>) -> SourceItemId {
+        db.as_ref().id2loc(self)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DefId(u32);
+ra_db::impl_numeric_id!(DefId);
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum DefLoc {
+    Module {
+        id: ModuleId,
+        source_root: SourceRootId,
+    },
+    Item {
+        source_item_id: SourceItemId,
+    },
+}
+impl DefId {
+    pub fn loc(self, db: &impl AsRef<LocationIntener<DefLoc, DefId>>) -> DefLoc {
+        db.as_ref().id2loc(self)
+    }
+}
+impl DefLoc {
+    pub fn id(&self, db: &impl AsRef<LocationIntener<DefLoc, DefId>>) -> DefId {
+        db.as_ref().loc2id(&self)
+    }
+}
+pub enum Def {
+    Module(Module),
+    Item,
+}
+impl DefId {
+    pub fn resolve(self, db: &impl HirDatabase) -> Cancelable<Def> {
+        let loc = self.loc(db);
+        let res = match loc {
+            DefLoc::Module { id, source_root } => {
+                let descr = Module::new(db, source_root, id)?;
+                Def::Module(descr)
+            }
+            DefLoc::Item { .. } => Def::Item,
+        };
+        Ok(res)
+    }
+}
+/// Identifier of item within a specific file. This is stable over reparses, so
+/// it's OK to use it as a salsa key/value.
+pub(crate) type SourceFileItemId = Id<SyntaxNode>;
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct SourceItemId {
+    file_id: FileId,
+    item_id: SourceFileItemId,
+}
+/// Maps item's `SyntaxNode`s to `SourceFileItemId` and back.
+#[derive(Debug, PartialEq, Eq, Default)]
+pub struct SourceFileItems {
+    arena: Arena<SyntaxNode>,
+}
+impl SourceFileItems {
+    fn alloc(&mut self, item: SyntaxNode) -> SourceFileItemId {
+        self.arena.alloc(item)
+    }
+    pub fn id_of(&self, item: SyntaxNodeRef) -> SourceFileItemId {
+        let (id, _item) = self
+            .arena
+            .iter()
+            .find(|(_id, i)| i.borrowed() == item)
+            .unwrap();
+        id
+    }
+}
+impl Index<SourceFileItemId> for SourceFileItems {
+    type Output = SyntaxNode;
+    fn index(&self, idx: SourceFileItemId) -> &SyntaxNode {
+        &self.arena[idx]
+    }
+}
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
new file mode 100644
index 000000000..8e256b89f
--- /dev/null
+++ b/crates/ra_hir/src/mock.rs
@@ -0,0 +1,172 @@
+use std::sync::Arc;
+use parking_lot::Mutex;
+use salsa::{self, Database};
+use ra_db::{LocationIntener, BaseDatabase, FilePosition, mock::FileMap, FileId, WORKSPACE};
+use relative_path::RelativePathBuf;
+use test_utils::{parse_fixture, CURSOR_MARKER, extract_offset};
+use crate::{db, DefId, DefLoc, FnId, SourceItemId};
+#[derive(Debug)]
+pub(crate) struct MockDatabase {
+    events: Mutex<Option<Vec<salsa::Event<MockDatabase>>>>,
+    runtime: salsa::Runtime<MockDatabase>,
+    id_maps: Arc<IdMaps>,
+}
+impl MockDatabase {
+    pub(crate) fn with_position(fixture: &str) -> (MockDatabase, FilePosition) {
+        let mut db = MockDatabase::default();
+        let mut position = None;
+        let mut file_map = FileMap::default();
+        for entry in parse_fixture(fixture) {
+            if entry.text.contains(CURSOR_MARKER) {
+                assert!(
+                    position.is_none(),
+                    "only one marker (<|>) per fixture is allowed"
+                );
+                position = Some(db.add_file_with_position(&mut file_map, &entry.meta, &entry.text));
+            } else {
+                db.add_file(&mut file_map, &entry.meta, &entry.text);
+            }
+        }
+        let position = position.expect("expected a marker (<|>)");
+        let source_root = file_map.into_source_root();
+        db.query_mut(ra_db::SourceRootQuery)
+            .set(WORKSPACE, Arc::new(source_root));
+        (db, position)
+    }
+    fn add_file(&mut self, file_map: &mut FileMap, path: &str, text: &str) -> FileId {
+        assert!(path.starts_with('/'));
+        let path = RelativePathBuf::from_path(&path[1..]).unwrap();
+        let file_id = file_map.add(path);
+        let text = Arc::new(text.to_string());
+        self.query_mut(ra_db::FileTextQuery).set(file_id, text);
+        self.query_mut(ra_db::FileSourceRootQuery)
+            .set(file_id, WORKSPACE);
+        file_id
+    }
+    fn add_file_with_position(
+        &mut self,
+        file_map: &mut FileMap,
+        path: &str,
+        text: &str,
+    ) -> FilePosition {
+        let (offset, text) = extract_offset(text);
+        let file_id = self.add_file(file_map, path, &text);
+        FilePosition { file_id, offset }
+    }
+}
+#[derive(Debug, Default)]
+struct IdMaps {
+    fns: LocationIntener<SourceItemId, FnId>,
+    defs: LocationIntener<DefLoc, DefId>,
+}
+impl salsa::Database for MockDatabase {
+    fn salsa_runtime(&self) -> &salsa::Runtime<MockDatabase> {
+        &self.runtime
+    }
+    fn salsa_event(&self, event: impl Fn() -> salsa::Event<MockDatabase>) {
+        let mut events = self.events.lock();
+        if let Some(events) = &mut *events {
+            events.push(event());
+        }
+    }
+}
+impl Default for MockDatabase {
+    fn default() -> MockDatabase {
+        let mut db = MockDatabase {
+            events: Default::default(),
+            runtime: salsa::Runtime::default(),
+            id_maps: Default::default(),
+        };
+        db.query_mut(ra_db::SourceRootQuery)
+            .set(ra_db::WORKSPACE, Default::default());
+        db.query_mut(ra_db::CrateGraphQuery)
+            .set((), Default::default());
+        db.query_mut(ra_db::LibrariesQuery)
+            .set((), Default::default());
+        db
+    }
+}
+impl salsa::ParallelDatabase for MockDatabase {
+    fn snapshot(&self) -> salsa::Snapshot<MockDatabase> {
+        salsa::Snapshot::new(MockDatabase {
+            events: Default::default(),
+            runtime: self.runtime.snapshot(self),
+            id_maps: self.id_maps.clone(),
+        })
+    }
+}
+impl BaseDatabase for MockDatabase {}
+impl AsRef<LocationIntener<DefLoc, DefId>> for MockDatabase {
+    fn as_ref(&self) -> &LocationIntener<DefLoc, DefId> {
+        &self.id_maps.defs
+    }
+}
+impl AsRef<LocationIntener<SourceItemId, FnId>> for MockDatabase {
+    fn as_ref(&self) -> &LocationIntener<SourceItemId, FnId> {
+        &self.id_maps.fns
+    }
+}
+impl MockDatabase {
+    pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event<MockDatabase>> {
+        *self.events.lock() = Some(Vec::new());
+        f();
+        let events = self.events.lock().take().unwrap();
+        events
+    }
+    pub(crate) fn log_executed(&self, f: impl FnOnce()) -> Vec<String> {
+        let events = self.log(f);
+        events
+            .into_iter()
+            .filter_map(|e| match e.kind {
+                // This pretty horrible, but `Debug` is the only way to inspect
+                // QueryDescriptor at the moment.
+                salsa::EventKind::WillExecute { descriptor } => Some(format!("{:?}", descriptor)),
+                _ => None,
+            })
+            .collect()
+    }
+}
+salsa::database_storage! {
+    pub(crate) struct MockDatabaseStorage for MockDatabase {
+        impl ra_db::FilesDatabase {
+            fn file_text() for ra_db::FileTextQuery;
+            fn file_source_root() for ra_db::FileSourceRootQuery;
+            fn source_root() for ra_db::SourceRootQuery;
+            fn libraries() for ra_db::LibrariesQuery;
+            fn crate_graph() for ra_db::CrateGraphQuery;
+        }
+        impl ra_db::SyntaxDatabase {
+            fn source_file() for ra_db::SourceFileQuery;
+            fn file_lines() for ra_db::FileLinesQuery;
+        }
+        impl db::HirDatabase {
+            fn module_tree() for db::ModuleTreeQuery;
+            fn fn_scopes() for db::FnScopesQuery;
+            fn file_items() for db::SourceFileItemsQuery;
+            fn file_item() for db::FileItemQuery;
+            fn input_module_items() for db::InputModuleItemsQuery;
+            fn item_map() for db::ItemMapQuery;
+            fn fn_syntax() for db::FnSyntaxQuery;
+            fn submodules() for db::SubmodulesQuery;
+        }
+    }
+}
diff --git a/crates/ra_analysis/src/descriptors/module/imp.rs b/crates/ra_hir/src/module/imp.rs
index ade96ddc0..76ea129a7 100644
--- a/crates/ra_analysis/src/descriptors/module/imp.rs
+++ b/crates/ra_hir/src/module/imp.rs
@@ -1,26 +1,24 @@
 use std::sync::Arc;
 use ra_syntax::{
-    ast::{self, ModuleItemOwner, NameOwner},
+    ast::{self, NameOwner},
    SmolStr,
 };
 use relative_path::RelativePathBuf;
 use rustc_hash::{FxHashMap, FxHashSet};
+use ra_db::{SourceRoot, SourceRootId, FileResolverImp, Cancelable, FileId,};
 use crate::{
-    db,
+    HirDatabase,
-    descriptors::DescriptorDatabase,
-    input::{SourceRoot, SourceRootId},
-    Cancelable, FileId, FileResolverImp,
 };
 use super::{
-    LinkData, LinkId, ModuleData, ModuleId, ModuleScope, ModuleSource, ModuleSourceNode,
+    LinkData, LinkId, ModuleData, ModuleId, ModuleSource,
    ModuleTree, Problem,
 };
 #[derive(Clone, Hash, PartialEq, Eq, Debug)]
-pub(crate) enum Submodule {
+pub enum Submodule {
    Declaration(SmolStr),
    Definition(SmolStr, ModuleSource),
 }
@@ -34,39 +32,6 @@ impl Submodule {
    }
 }
-pub(crate) fn submodules(
-    db: &impl DescriptorDatabase,
-    source: ModuleSource,
-) -> Cancelable<Arc<Vec<Submodule>>> {
-    db::check_canceled(db)?;
-    let file_id = source.file_id();
-    let submodules = match source.resolve(db) {
-        ModuleSourceNode::SourceFile(it) => collect_submodules(file_id, it.borrowed()),
-        ModuleSourceNode::Module(it) => it
-            .borrowed()
-            .item_list()
-            .map(|it| collect_submodules(file_id, it))
-            .unwrap_or_else(Vec::new),
-    };
-    return Ok(Arc::new(submodules));
-    fn collect_submodules<'a>(
-        file_id: FileId,
-        root: impl ast::ModuleItemOwner<'a>,
-    ) -> Vec<Submodule> {
-        modules(root)
-            .map(|(name, m)| {
-                if m.has_semi() {
-                    Submodule::Declaration(name)
-                } else {
-                    let src = ModuleSource::new_inline(file_id, m);
-                    Submodule::Definition(name, src)
-                }
-            })
-            .collect()
-    }
-}
 pub(crate) fn modules<'a>(
    root: impl ast::ModuleItemOwner<'a>,
 ) -> impl Iterator<Item = (SmolStr, ast::Module<'a>)> {
@@ -81,40 +46,20 @@ pub(crate) fn modules<'a>(
        })
 }
-pub(crate) fn module_scope(
-    db: &impl DescriptorDatabase,
-    source_root_id: SourceRootId,
-    module_id: ModuleId,
-) -> Cancelable<Arc<ModuleScope>> {
-    let tree = db.module_tree(source_root_id)?;
-    let source = module_id.source(&tree).resolve(db);
-    let res = match source {
-        ModuleSourceNode::SourceFile(it) => ModuleScope::new(it.borrowed().items()),
-        ModuleSourceNode::Module(it) => match it.borrowed().item_list() {
-            Some(items) => ModuleScope::new(items.items()),
-            None => ModuleScope::new(std::iter::empty()),
-        },
-    };
-    Ok(Arc::new(res))
-}
 pub(crate) fn module_tree(
-    db: &impl DescriptorDatabase,
+    db: &impl HirDatabase,
    source_root: SourceRootId,
 ) -> Cancelable<Arc<ModuleTree>> {
-    db::check_canceled(db)?;
+    db.check_canceled()?;
    let res = create_module_tree(db, source_root)?;
    Ok(Arc::new(res))
 }
 fn create_module_tree<'a>(
-    db: &impl DescriptorDatabase,
+    db: &impl HirDatabase,
    source_root: SourceRootId,
 ) -> Cancelable<ModuleTree> {
-    let mut tree = ModuleTree {
+    let mut tree = ModuleTree::default();
-        mods: Vec::new(),
-        links: Vec::new(),
-    };
    let mut roots = FxHashMap::default();
    let mut visited = FxHashSet::default();
@@ -141,7 +86,7 @@ fn create_module_tree<'a>(
 }
 fn build_subtree(
-    db: &impl DescriptorDatabase,
+    db: &impl HirDatabase,
    source_root: &SourceRoot,
    tree: &mut ModuleTree,
    visited: &mut FxHashSet<ModuleSource>,
@@ -171,7 +116,7 @@ fn build_subtree(
                    .into_iter()
                    .map(|file_id| match roots.remove(&file_id) {
                        Some(module_id) => {
-                            tree.module_mut(module_id).parent = Some(link);
+                            tree.mods[module_id].parent = Some(link);
                            Ok(module_id)
                        }
                        None => build_subtree(
@@ -201,8 +146,8 @@ fn build_subtree(
            }
        };
-        tree.link_mut(link).points_to = points_to;
+        tree.links[link].points_to = points_to;
-        tree.link_mut(link).problem = problem;
+        tree.links[link].problem = problem;
    }
    Ok(id)
 }
diff --git a/crates/ra_hir/src/module/mod.rs b/crates/ra_hir/src/module/mod.rs
new file mode 100644
index 000000000..3ae83d8cb
--- /dev/null
+++ b/crates/ra_hir/src/module/mod.rs
@@ -0,0 +1,373 @@
+pub(super) mod imp;
+pub(super) mod nameres;
+use std::sync::Arc;
+use ra_editor::find_node_at_offset;
+use ra_syntax::{
+    algo::generate,
+    ast::{self, AstNode, NameOwner},
+    SmolStr, SyntaxNode,
+};
+use ra_db::{SourceRootId, FileId, FilePosition, Cancelable};
+use relative_path::RelativePathBuf;
+use crate::{
+    DefLoc, DefId, Path, PathKind, HirDatabase, SourceItemId,
+    arena::{Arena, Id},
+};
+pub use self::nameres::ModuleScope;
+/// `Module` is API entry point to get all the information
+/// about a particular module.
+#[derive(Debug, Clone)]
+pub struct Module {
+    tree: Arc<ModuleTree>,
+    source_root_id: SourceRootId,
+    module_id: ModuleId,
+}
+impl Module {
+    /// Lookup `Module` by `FileId`. Note that this is inherently
+    /// lossy transformation: in general, a single source might correspond to
+    /// several modules.
+    pub fn guess_from_file_id(
+        db: &impl HirDatabase,
+        file_id: FileId,
+    ) -> Cancelable<Option<Module>> {
+        Module::guess_from_source(db, file_id, ModuleSource::SourceFile(file_id))
+    }
+    /// Lookup `Module` by position in the source code. Note that this
+    /// is inherently lossy transformation: in general, a single source might
+    /// correspond to several modules.
+    pub fn guess_from_position(
+        db: &impl HirDatabase,
+        position: FilePosition,
+    ) -> Cancelable<Option<Module>> {
+        let file = db.source_file(position.file_id);
+        let module_source = match find_node_at_offset::<ast::Module>(file.syntax(), position.offset)
+        {
+            Some(m) if !m.has_semi() => ModuleSource::new_inline(db, position.file_id, m),
+            _ => ModuleSource::SourceFile(position.file_id),
+        };
+        Module::guess_from_source(db, position.file_id, module_source)
+    }
+    fn guess_from_source(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        module_source: ModuleSource,
+    ) -> Cancelable<Option<Module>> {
+        let source_root_id = db.file_source_root(file_id);
+        let module_tree = db.module_tree(source_root_id)?;
+        let res = match module_tree.any_module_for_source(module_source) {
+            None => None,
+            Some(module_id) => Some(Module {
+                tree: module_tree,
+                source_root_id,
+                module_id,
+            }),
+        };
+        Ok(res)
+    }
+    pub(super) fn new(
+        db: &impl HirDatabase,
+        source_root_id: SourceRootId,
+        module_id: ModuleId,
+    ) -> Cancelable<Module> {
+        let module_tree = db.module_tree(source_root_id)?;
+        let res = Module {
+            tree: module_tree,
+            source_root_id,
+            module_id,
+        };
+        Ok(res)
+    }
+    /// Returns `mod foo;` or `mod foo {}` node whihc declared this module.
+    /// Returns `None` for the root module
+    pub fn parent_link_source(&self, db: &impl HirDatabase) -> Option<(FileId, ast::ModuleNode)> {
+        let link = self.module_id.parent_link(&self.tree)?;
+        let file_id = link.owner(&self.tree).source(&self.tree).file_id();
+        let src = link.bind_source(&self.tree, db);
+        Some((file_id, src))
+    }
+    pub fn source(&self) -> ModuleSource {
+        self.module_id.source(&self.tree)
+    }
+    /// Parent module. Returns `None` if this is a root module.
+    pub fn parent(&self) -> Option<Module> {
+        let parent_id = self.module_id.parent(&self.tree)?;
+        Some(Module {
+            module_id: parent_id,
+            ..self.clone()
+        })
+    }
+    /// The root of the tree this module is part of
+    pub fn crate_root(&self) -> Module {
+        let root_id = self.module_id.crate_root(&self.tree);
+        Module {
+            module_id: root_id,
+            ..self.clone()
+        }
+    }
+    /// `name` is `None` for the crate's root module
+    pub fn name(&self) -> Option<SmolStr> {
+        let link = self.module_id.parent_link(&self.tree)?;
+        Some(link.name(&self.tree))
+    }
+    pub fn def_id(&self, db: &impl HirDatabase) -> DefId {
+        let def_loc = DefLoc::Module {
+            id: self.module_id,
+            source_root: self.source_root_id,
+        };
+        def_loc.id(db)
+    }
+    /// Finds a child module with the specified name.
+    pub fn child(&self, name: &str) -> Option<Module> {
+        let child_id = self.module_id.child(&self.tree, name)?;
+        Some(Module {
+            module_id: child_id,
+            ..self.clone()
+        })
+    }
+    /// Returns a `ModuleScope`: a set of items, visible in this module.
+    pub fn scope(&self, db: &impl HirDatabase) -> Cancelable<ModuleScope> {
+        let item_map = db.item_map(self.source_root_id)?;
+        let res = item_map.per_module[&self.module_id].clone();
+        Ok(res)
+    }
+    pub fn resolve_path(&self, db: &impl HirDatabase, path: Path) -> Cancelable<Option<DefId>> {
+        let mut curr = match path.kind {
+            PathKind::Crate => self.crate_root(),
+            PathKind::Self_ | PathKind::Plain => self.clone(),
+            PathKind::Super => ctry!(self.parent()),
+        }
+        .def_id(db);
+        let segments = path.segments;
+        for name in segments.iter() {
+            let module = match curr.loc(db) {
+                DefLoc::Module { id, source_root } => Module::new(db, source_root, id)?,
+                _ => return Ok(None),
+            };
+            let scope = module.scope(db)?;
+            curr = ctry!(ctry!(scope.get(&name)).def_id);
+        }
+        Ok(Some(curr))
+    }
+    pub fn problems(&self, db: &impl HirDatabase) -> Vec<(SyntaxNode, Problem)> {
+        self.module_id.problems(&self.tree, db)
+    }
+}
+/// Phisically, rust source is organized as a set of files, but logically it is
+/// organized as a tree of modules. Usually, a single file corresponds to a
+/// single module, but it is not nessary the case.
+///
+/// Module encapsulate the logic of transitioning from the fuzzy world of files
+/// (which can have multiple parents) to the precise world of modules (which
+/// always have one parent).
+#[derive(Default, Debug, PartialEq, Eq)]
+pub struct ModuleTree {
+    mods: Arena<ModuleData>,
+    links: Arena<LinkData>,
+}
+impl ModuleTree {
+    pub(crate) fn modules<'a>(&'a self) -> impl Iterator<Item = ModuleId> + 'a {
+        self.mods.iter().map(|(id, _)| id)
+    }
+    fn modules_for_source(&self, source: ModuleSource) -> Vec<ModuleId> {
+        self.mods
+            .iter()
+            .filter(|(_idx, it)| it.source == source)
+            .map(|(idx, _)| idx)
+            .collect()
+    }
+    fn any_module_for_source(&self, source: ModuleSource) -> Option<ModuleId> {
+        self.modules_for_source(source).pop()
+    }
+}
+/// `ModuleSource` is the syntax tree element that produced this module:
+/// either a file, or an inlinde module.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum ModuleSource {
+    SourceFile(FileId),
+    Module(SourceItemId),
+}
+/// An owned syntax node for a module. Unlike `ModuleSource`,
+/// this holds onto the AST for the whole file.
+pub(crate) enum ModuleSourceNode {
+    SourceFile(ast::SourceFileNode),
+    Module(ast::ModuleNode),
+}
+pub type ModuleId = Id<ModuleData>;
+type LinkId = Id<LinkData>;
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum Problem {
+    UnresolvedModule {
+        candidate: RelativePathBuf,
+    },
+    NotDirOwner {
+        move_to: RelativePathBuf,
+        candidate: RelativePathBuf,
+    },
+}
+impl ModuleId {
+    pub(crate) fn source(self, tree: &ModuleTree) -> ModuleSource {
+        tree.mods[self].source
+    }
+    fn parent_link(self, tree: &ModuleTree) -> Option<LinkId> {
+        tree.mods[self].parent
+    }
+    fn parent(self, tree: &ModuleTree) -> Option<ModuleId> {
+        let link = self.parent_link(tree)?;
+        Some(tree.links[link].owner)
+    }
+    fn crate_root(self, tree: &ModuleTree) -> ModuleId {
+        generate(Some(self), move |it| it.parent(tree))
+            .last()
+            .unwrap()
+    }
+    fn child(self, tree: &ModuleTree, name: &str) -> Option<ModuleId> {
+        let link = tree.mods[self]
+            .children
+            .iter()
+            .map(|&it| &tree.links[it])
+            .find(|it| it.name == name)?;
+        Some(*link.points_to.first()?)
+    }
+    fn children<'a>(self, tree: &'a ModuleTree) -> impl Iterator<Item = (SmolStr, ModuleId)> + 'a {
+        tree.mods[self].children.iter().filter_map(move |&it| {
+            let link = &tree.links[it];
+            let module = *link.points_to.first()?;
+            Some((link.name.clone(), module))
+        })
+    }
+    fn problems(self, tree: &ModuleTree, db: &impl HirDatabase) -> Vec<(SyntaxNode, Problem)> {
+        tree.mods[self]
+            .children
+            .iter()
+            .filter_map(|&it| {
+                let p = tree.links[it].problem.clone()?;
+                let s = it.bind_source(tree, db);
+                let s = s.borrowed().name().unwrap().syntax().owned();
+                Some((s, p))
+            })
+            .collect()
+    }
+}
+impl LinkId {
+    fn owner(self, tree: &ModuleTree) -> ModuleId {
+        tree.links[self].owner
+    }
+    fn name(self, tree: &ModuleTree) -> SmolStr {
+        tree.links[self].name.clone()
+    }
+    fn bind_source<'a>(self, tree: &ModuleTree, db: &impl HirDatabase) -> ast::ModuleNode {
+        let owner = self.owner(tree);
+        match owner.source(tree).resolve(db) {
+            ModuleSourceNode::SourceFile(root) => {
+                let ast = imp::modules(root.borrowed())
+                    .find(|(name, _)| name == &tree.links[self].name)
+                    .unwrap()
+                    .1;
+                ast.owned()
+            }
+            ModuleSourceNode::Module(it) => it,
+        }
+    }
+}
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct ModuleData {
+    source: ModuleSource,
+    parent: Option<LinkId>,
+    children: Vec<LinkId>,
+}
+impl ModuleSource {
+    pub(crate) fn new_inline(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        module: ast::Module,
+    ) -> ModuleSource {
+        assert!(!module.has_semi());
+        let items = db.file_items(file_id);
+        let item_id = items.id_of(module.syntax());
+        let id = SourceItemId { file_id, item_id };
+        ModuleSource::Module(id)
+    }
+    pub fn as_file(self) -> Option<FileId> {
+        match self {
+            ModuleSource::SourceFile(f) => Some(f),
+            ModuleSource::Module(..) => None,
+        }
+    }
+    pub fn file_id(self) -> FileId {
+        match self {
+            ModuleSource::SourceFile(f) => f,
+            ModuleSource::Module(source_item_id) => source_item_id.file_id,
+        }
+    }
+    pub(crate) fn resolve(self, db: &impl HirDatabase) -> ModuleSourceNode {
+        match self {
+            ModuleSource::SourceFile(file_id) => {
+                let syntax = db.source_file(file_id);
+                ModuleSourceNode::SourceFile(syntax.ast().owned())
+            }
+            ModuleSource::Module(item_id) => {
+                let syntax = db.file_item(item_id);
+                let syntax = syntax.borrowed();
+                let module = ast::Module::cast(syntax).unwrap();
+                ModuleSourceNode::Module(module.owned())
+            }
+        }
+    }
+}
+#[derive(Hash, Debug, PartialEq, Eq)]
+struct LinkData {
+    owner: ModuleId,
+    name: SmolStr,
+    points_to: Vec<ModuleId>,
+    problem: Option<Problem>,
+}
+impl ModuleTree {
+    fn push_mod(&mut self, data: ModuleData) -> ModuleId {
+        self.mods.alloc(data)
+    }
+    fn push_link(&mut self, data: LinkData) -> LinkId {
+        let owner = data.owner;
+        let id = self.links.alloc(data);
+        self.mods[owner].children.push(id);
+        id
+    }
+}
diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs
new file mode 100644
index 000000000..8529e16b3
--- /dev/null
+++ b/crates/ra_hir/src/module/nameres.rs
@@ -0,0 +1,434 @@
+//! Name resolution algorithm. The end result of the algorithm is `ItemMap`: a
+//! map with maps each module to it's scope: the set of items, visible in the
+//! module. That is, we only resolve imports here, name resolution of item
+//! bodies will be done in a separate step.
+//!
+//! Like Rustc, we use an interative per-crate algorithm: we start with scopes
+//! containing only directly defined items, and then iteratively resolve
+//! imports.
+//!
+//! To make this work nicely in the IDE scenarios, we place `InputModuleItems`
+//! in between raw syntax and name resolution. `InputModuleItems` are computed
+//! using only the module's syntax, and it is all directly defined items plus
+//! imports. The plain is to make `InputModuleItems` independent of local
+//! modifications (that is, typing inside a function shold not change IMIs),
+//! such that the results of name resolution can be preserved unless the module
+//! structure itself is modified.
+use std::{
+    sync::Arc,
+};
+use rustc_hash::FxHashMap;
+use ra_syntax::{
+    TextRange,
+    SmolStr, SyntaxKind::{self, *},
+    ast::{self, AstNode}
+};
+use ra_db::SourceRootId;
+use crate::{
+    Cancelable, FileId,
+    DefId, DefLoc,
+    SourceItemId, SourceFileItemId, SourceFileItems,
+    Path, PathKind,
+    HirDatabase,
+    module::{ModuleId, ModuleTree},
+};
+/// Item map is the result of the name resolution. Item map contains, for each
+/// module, the set of visible items.
+#[derive(Default, Debug, PartialEq, Eq)]
+pub struct ItemMap {
+    pub per_module: FxHashMap<ModuleId, ModuleScope>,
+}
+#[derive(Debug, Default, PartialEq, Eq, Clone)]
+pub struct ModuleScope {
+    items: FxHashMap<SmolStr, Resolution>,
+}
+impl ModuleScope {
+    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a SmolStr, &Resolution)> + 'a {
+        self.items.iter()
+    }
+    pub fn get(&self, name: &SmolStr) -> Option<&Resolution> {
+        self.items.get(name)
+    }
+}
+/// A set of items and imports declared inside a module, without relation to
+/// other modules.
+///
+/// This stands in-between raw syntax and name resolution and alow us to avoid
+/// recomputing name res: if `InputModuleItems` are the same, we can avoid
+/// running name resolution.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct InputModuleItems {
+    items: Vec<ModuleItem>,
+    imports: Vec<Import>,
+}
+#[derive(Debug, PartialEq, Eq)]
+struct ModuleItem {
+    id: SourceFileItemId,
+    name: SmolStr,
+    kind: SyntaxKind,
+    vis: Vis,
+}
+#[derive(Debug, PartialEq, Eq)]
+enum Vis {
+    // Priv,
+    Other,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct Import {
+    path: Path,
+    kind: ImportKind,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct NamedImport {
+    pub file_item_id: SourceFileItemId,
+    pub relative_range: TextRange,
+}
+impl NamedImport {
+    pub fn range(&self, db: &impl HirDatabase, file_id: FileId) -> TextRange {
+        let source_item_id = SourceItemId {
+            file_id,
+            item_id: self.file_item_id,
+        };
+        let syntax = db.file_item(source_item_id);
+        let offset = syntax.borrowed().range().start();
+        self.relative_range + offset
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum ImportKind {
+    Glob,
+    Named(NamedImport),
+}
+/// Resolution is basically `DefId` atm, but it should account for stuff like
+/// multiple namespaces, ambiguity and errors.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Resolution {
+    /// None for unresolved
+    pub def_id: Option<DefId>,
+    /// ident by whitch this is imported into local scope.
+    pub import: Option<NamedImport>,
+}
+// #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+// enum Namespace {
+//     Types,
+//     Values,
+// }
+// #[derive(Debug)]
+// struct PerNs<T> {
+//     types: Option<T>,
+//     values: Option<T>,
+// }
+impl InputModuleItems {
+    pub(crate) fn new<'a>(
+        file_items: &SourceFileItems,
+        items: impl Iterator<Item = ast::ModuleItem<'a>>,
+    ) -> InputModuleItems {
+        let mut res = InputModuleItems::default();
+        for item in items {
+            res.add_item(file_items, item);
+        }
+        res
+    }
+    fn add_item(&mut self, file_items: &SourceFileItems, item: ast::ModuleItem) -> Option<()> {
+        match item {
+            ast::ModuleItem::StructDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
+            ast::ModuleItem::EnumDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
+            ast::ModuleItem::FnDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
+            ast::ModuleItem::TraitDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
+            ast::ModuleItem::TypeDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
+            ast::ModuleItem::ImplItem(_) => {
+                // impls don't define items
+            }
+            ast::ModuleItem::UseItem(it) => self.add_use_item(file_items, it),
+            ast::ModuleItem::ExternCrateItem(_) => {
+                // TODO
+            }
+            ast::ModuleItem::ConstDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
+            ast::ModuleItem::StaticDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
+            ast::ModuleItem::Module(it) => self.items.push(ModuleItem::new(file_items, it)?),
+        }
+        Some(())
+    }
+    fn add_use_item(&mut self, file_items: &SourceFileItems, item: ast::UseItem) {
+        let file_item_id = file_items.id_of(item.syntax());
+        let start_offset = item.syntax().range().start();
+        Path::expand_use_item(item, |path, range| {
+            let kind = match range {
+                None => ImportKind::Glob,
+                Some(range) => ImportKind::Named(NamedImport {
+                    file_item_id,
+                    relative_range: range - start_offset,
+                }),
+            };
+            self.imports.push(Import { kind, path })
+        })
+    }
+}
+impl ModuleItem {
+    fn new<'a>(file_items: &SourceFileItems, item: impl ast::NameOwner<'a>) -> Option<ModuleItem> {
+        let name = item.name()?.text();
+        let kind = item.syntax().kind();
+        let vis = Vis::Other;
+        let id = file_items.id_of(item.syntax());
+        let res = ModuleItem {
+            id,
+            name,
+            kind,
+            vis,
+        };
+        Some(res)
+    }
+}
+pub(crate) struct Resolver<'a, DB> {
+    pub(crate) db: &'a DB,
+    pub(crate) input: &'a FxHashMap<ModuleId, Arc<InputModuleItems>>,
+    pub(crate) source_root: SourceRootId,
+    pub(crate) module_tree: Arc<ModuleTree>,
+    pub(crate) result: ItemMap,
+}
+impl<'a, DB> Resolver<'a, DB>
+where
+    DB: HirDatabase,
+{
+    pub(crate) fn resolve(mut self) -> Cancelable<ItemMap> {
+        for (&module_id, items) in self.input.iter() {
+            self.populate_module(module_id, items)
+        }
+        for &module_id in self.input.keys() {
+            self.db.check_canceled()?;
+            self.resolve_imports(module_id);
+        }
+        Ok(self.result)
+    }
+    fn populate_module(&mut self, module_id: ModuleId, input: &InputModuleItems) {
+        let file_id = module_id.source(&self.module_tree).file_id();
+        let mut module_items = ModuleScope::default();
+        for import in input.imports.iter() {
+            if let Some(name) = import.path.segments.iter().last() {
+                if let ImportKind::Named(import) = import.kind {
+                    module_items.items.insert(
+                        name.clone(),
+                        Resolution {
+                            def_id: None,
+                            import: Some(import),
+                        },
+                    );
+                }
+            }
+        }
+        for item in input.items.iter() {
+            if item.kind == MODULE {
+                // handle submodules separatelly
+                continue;
+            }
+            let def_loc = DefLoc::Item {
+                source_item_id: SourceItemId {
+                    file_id,
+                    item_id: item.id,
+                },
+            };
+            let def_id = def_loc.id(self.db);
+            let resolution = Resolution {
+                def_id: Some(def_id),
+                import: None,
+            };
+            module_items.items.insert(item.name.clone(), resolution);
+        }
+        for (name, mod_id) in module_id.children(&self.module_tree) {
+            let def_loc = DefLoc::Module {
+                id: mod_id,
+                source_root: self.source_root,
+            };
+            let def_id = def_loc.id(self.db);
+            let resolution = Resolution {
+                def_id: Some(def_id),
+                import: None,
+            };
+            module_items.items.insert(name, resolution);
+        }
+        self.result.per_module.insert(module_id, module_items);
+    }
+    fn resolve_imports(&mut self, module_id: ModuleId) {
+        for import in self.input[&module_id].imports.iter() {
+            self.resolve_import(module_id, import);
+        }
+    }
+    fn resolve_import(&mut self, module_id: ModuleId, import: &Import) {
+        let ptr = match import.kind {
+            ImportKind::Glob => return,
+            ImportKind::Named(ptr) => ptr,
+        };
+        let mut curr = match import.path.kind {
+            // TODO: handle extern crates
+            PathKind::Plain => return,
+            PathKind::Self_ => module_id,
+            PathKind::Super => {
+                match module_id.parent(&self.module_tree) {
+                    Some(it) => it,
+                    // TODO: error
+                    None => return,
+                }
+            }
+            PathKind::Crate => module_id.crate_root(&self.module_tree),
+        };
+        for (i, name) in import.path.segments.iter().enumerate() {
+            let is_last = i == import.path.segments.len() - 1;
+            let def_id = match self.result.per_module[&curr].items.get(name) {
+                None => return,
+                Some(res) => match res.def_id {
+                    Some(it) => it,
+                    None => return,
+                },
+            };
+            if !is_last {
+                curr = match def_id.loc(self.db) {
+                    DefLoc::Module { id, .. } => id,
+                    _ => return,
+                }
+            } else {
+                self.update(module_id, |items| {
+                    let res = Resolution {
+                        def_id: Some(def_id),
+                        import: Some(ptr),
+                    };
+                    items.items.insert(name.clone(), res);
+                })
+            }
+        }
+    }
+    fn update(&mut self, module_id: ModuleId, f: impl FnOnce(&mut ModuleScope)) {
+        let module_items = self.result.per_module.get_mut(&module_id).unwrap();
+        f(module_items)
+    }
+}
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use salsa::Database;
+    use ra_db::FilesDatabase;
+    use ra_syntax::SmolStr;
+    use crate::{
+        self as hir,
+        db::HirDatabase,
+        mock::MockDatabase,
+};
+    fn item_map(fixture: &str) -> (Arc<hir::ItemMap>, hir::ModuleId) {
+        let (db, pos) = MockDatabase::with_position(fixture);
+        let source_root = db.file_source_root(pos.file_id);
+        let module = hir::Module::guess_from_position(&db, pos).unwrap().unwrap();
+        let module_id = module.module_id;
+        (db.item_map(source_root).unwrap(), module_id)
+    }
+    #[test]
+    fn test_item_map() {
+        let (item_map, module_id) = item_map(
+            "
+            //- /lib.rs
+            mod foo;
+            use crate::foo::bar::Baz;
+            <|>
+            //- /foo/mod.rs
+            pub mod bar;
+            //- /foo/bar.rs
+            pub struct Baz;
+        ",
+        );
+        let name = SmolStr::from("Baz");
+        let resolution = &item_map.per_module[&module_id].items[&name];
+        assert!(resolution.def_id.is_some());
+    }
+    #[test]
+    fn typing_inside_a_function_should_not_invalidate_item_map() {
+        let (mut db, pos) = MockDatabase::with_position(
+            "
+            //- /lib.rs
+            mod foo;<|>
+            use crate::foo::bar::Baz;
+            fn foo() -> i32 {
+                1 + 1
+            }
+            //- /foo/mod.rs
+            pub mod bar;
+            //- /foo/bar.rs
+            pub struct Baz;
+        ",
+        );
+        let source_root = db.file_source_root(pos.file_id);
+        {
+            let events = db.log_executed(|| {
+                db.item_map(source_root).unwrap();
+            });
+            assert!(format!("{:?}", events).contains("item_map"))
+        }
+        let new_text = "
+            mod foo;
+            use crate::foo::bar::Baz;
+            fn foo() -> i32 { 92 }
+        "
+        .to_string();
+        db.query_mut(ra_db::FileTextQuery)
+            .set(pos.file_id, Arc::new(new_text));
+        {
+            let events = db.log_executed(|| {
+                db.item_map(source_root).unwrap();
+            });
+            assert!(
+                !format!("{:?}", events).contains("_item_map"),
+                "{:#?}",
+                events
+            )
+        }
+    }
+}
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
new file mode 100644
index 000000000..4a2e427cd
--- /dev/null
+++ b/crates/ra_hir/src/path.rs
@@ -0,0 +1,148 @@
+use ra_syntax::{SmolStr, ast, AstNode, TextRange};
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Path {
+    pub kind: PathKind,
+    pub segments: Vec<SmolStr>,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PathKind {
+    Plain,
+    Self_,
+    Super,
+    Crate,
+}
+impl Path {
+    /// Calls `cb` with all paths, represented by this use item.
+    pub fn expand_use_item(item: ast::UseItem, mut cb: impl FnMut(Path, Option<TextRange>)) {
+        if let Some(tree) = item.use_tree() {
+            expand_use_tree(None, tree, &mut cb);
+        }
+    }
+    /// Converts an `ast::Path` to `Path`. Works with use trees.
+    pub fn from_ast(mut path: ast::Path) -> Option<Path> {
+        let mut kind = PathKind::Plain;
+        let mut segments = Vec::new();
+        loop {
+            let segment = path.segment()?;
+            match segment.kind()? {
+                ast::PathSegmentKind::Name(name) => segments.push(name.text()),
+                ast::PathSegmentKind::CrateKw => {
+                    kind = PathKind::Crate;
+                    break;
+                }
+                ast::PathSegmentKind::SelfKw => {
+                    kind = PathKind::Self_;
+                    break;
+                }
+                ast::PathSegmentKind::SuperKw => {
+                    kind = PathKind::Super;
+                    break;
+                }
+            }
+            path = match qualifier(path) {
+                Some(it) => it,
+                None => break,
+            };
+        }
+        segments.reverse();
+        return Some(Path { kind, segments });
+        fn qualifier(path: ast::Path) -> Option<ast::Path> {
+            if let Some(q) = path.qualifier() {
+                return Some(q);
+            }
+            // TODO: this bottom up traversal is not too precise.
+            // Should we handle do a top-down analysiss, recording results?
+            let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
+            let use_tree = use_tree_list.parent_use_tree();
+            use_tree.path()
+        }
+    }
+    /// `true` is this path is a single identifier, like `foo`
+    pub fn is_ident(&self) -> bool {
+        self.kind == PathKind::Plain && self.segments.len() == 1
+    }
+}
+fn expand_use_tree(
+    prefix: Option<Path>,
+    tree: ast::UseTree,
+    cb: &mut impl FnMut(Path, Option<TextRange>),
+) {
+    if let Some(use_tree_list) = tree.use_tree_list() {
+        let prefix = match tree.path() {
+            None => prefix,
+            Some(path) => match convert_path(prefix, path) {
+                Some(it) => Some(it),
+                None => return, // TODO: report errors somewhere
+            },
+        };
+        for tree in use_tree_list.use_trees() {
+            expand_use_tree(prefix.clone(), tree, cb);
+        }
+    } else {
+        if let Some(ast_path) = tree.path() {
+            if let Some(path) = convert_path(prefix, ast_path) {
+                let range = if tree.has_star() {
+                    None
+                } else {
+                    let range = ast_path.segment().unwrap().syntax().range();
+                    Some(range)
+                };
+                cb(path, range)
+            }
+        }
+    }
+}
+fn convert_path(prefix: Option<Path>, path: ast::Path) -> Option<Path> {
+    let prefix = if let Some(qual) = path.qualifier() {
+        Some(convert_path(prefix, qual)?)
+    } else {
+        None
+    };
+    let segment = path.segment()?;
+    let res = match segment.kind()? {
+        ast::PathSegmentKind::Name(name) => {
+            let mut res = prefix.unwrap_or_else(|| Path {
+                kind: PathKind::Plain,
+                segments: Vec::with_capacity(1),
+            });
+            res.segments.push(name.text());
+            res
+        }
+        ast::PathSegmentKind::CrateKw => {
+            if prefix.is_some() {
+                return None;
+            }
+            Path {
+                kind: PathKind::Crate,
+                segments: Vec::new(),
+            }
+        }
+        ast::PathSegmentKind::SelfKw => {
+            if prefix.is_some() {
+                return None;
+            }
+            Path {
+                kind: PathKind::Self_,
+                segments: Vec::new(),
+            }
+        }
+        ast::PathSegmentKind::SuperKw => {
+            if prefix.is_some() {
+                return None;
+            }
+            Path {
+                kind: PathKind::Super,
+                segments: Vec::new(),
+            }
+        }
+    };
+    Some(res)
+}
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
new file mode 100644
index 000000000..6f602878c
--- /dev/null
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -0,0 +1,154 @@
+use std::{
+    sync::Arc,
+    time::Instant,
+};
+use rustc_hash::FxHashMap;
+use ra_syntax::{
+    AstNode,  SyntaxNode, SmolStr,
+    ast::{self, FnDef, FnDefNode, NameOwner, ModuleItemOwner}
+};
+use ra_db::{SourceRootId, FileId, Cancelable,};
+use crate::{
+        FnId,
+        SourceFileItems, SourceItemId,
+        db::HirDatabase,
+        function::FnScopes,
+        module::{
+            ModuleSource, ModuleSourceNode, ModuleId,
+            imp::Submodule,
+            nameres::{InputModuleItems, ItemMap, Resolver},
+        },
+};
+/// Resolve `FnId` to the corresponding `SyntaxNode`
+pub(super) fn fn_syntax(db: &impl HirDatabase, fn_id: FnId) -> FnDefNode {
+    let item_id = fn_id.loc(db);
+    let syntax = db.file_item(item_id);
+    FnDef::cast(syntax.borrowed()).unwrap().owned()
+}
+pub(super) fn fn_scopes(db: &impl HirDatabase, fn_id: FnId) -> Arc<FnScopes> {
+    let syntax = db.fn_syntax(fn_id);
+    let res = FnScopes::new(syntax.borrowed());
+    Arc::new(res)
+}
+pub(super) fn file_items(db: &impl HirDatabase, file_id: FileId) -> Arc<SourceFileItems> {
+    let source_file = db.source_file(file_id);
+    let source_file = source_file.borrowed();
+    let mut res = SourceFileItems::default();
+    source_file
+        .syntax()
+        .descendants()
+        .filter_map(ast::ModuleItem::cast)
+        .map(|it| it.syntax().owned())
+        .for_each(|it| {
+            res.alloc(it);
+        });
+    Arc::new(res)
+}
+pub(super) fn file_item(db: &impl HirDatabase, source_item_id: SourceItemId) -> SyntaxNode {
+    db.file_items(source_item_id.file_id)[source_item_id.item_id].clone()
+}
+pub(crate) fn submodules(
+    db: &impl HirDatabase,
+    source: ModuleSource,
+) -> Cancelable<Arc<Vec<Submodule>>> {
+    db.check_canceled()?;
+    let file_id = source.file_id();
+    let submodules = match source.resolve(db) {
+        ModuleSourceNode::SourceFile(it) => collect_submodules(db, file_id, it.borrowed()),
+        ModuleSourceNode::Module(it) => it
+            .borrowed()
+            .item_list()
+            .map(|it| collect_submodules(db, file_id, it))
+            .unwrap_or_else(Vec::new),
+    };
+    return Ok(Arc::new(submodules));
+    fn collect_submodules<'a>(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        root: impl ast::ModuleItemOwner<'a>,
+    ) -> Vec<Submodule> {
+        modules(root)
+            .map(|(name, m)| {
+                if m.has_semi() {
+                    Submodule::Declaration(name)
+                } else {
+                    let src = ModuleSource::new_inline(db, file_id, m);
+                    Submodule::Definition(name, src)
+                }
+            })
+            .collect()
+    }
+}
+pub(crate) fn modules<'a>(
+    root: impl ast::ModuleItemOwner<'a>,
+) -> impl Iterator<Item = (SmolStr, ast::Module<'a>)> {
+    root.items()
+        .filter_map(|item| match item {
+            ast::ModuleItem::Module(m) => Some(m),
+            _ => None,
+        })
+        .filter_map(|module| {
+            let name = module.name()?.text();
+            Some((name, module))
+        })
+}
+pub(super) fn input_module_items(
+    db: &impl HirDatabase,
+    source_root: SourceRootId,
+    module_id: ModuleId,
+) -> Cancelable<Arc<InputModuleItems>> {
+    let module_tree = db.module_tree(source_root)?;
+    let source = module_id.source(&module_tree);
+    let file_items = db.file_items(source.file_id());
+    let res = match source.resolve(db) {
+        ModuleSourceNode::SourceFile(it) => {
+            let items = it.borrowed().items();
+            InputModuleItems::new(&file_items, items)
+        }
+        ModuleSourceNode::Module(it) => {
+            let items = it
+                .borrowed()
+                .item_list()
+                .into_iter()
+                .flat_map(|it| it.items());
+            InputModuleItems::new(&file_items, items)
+        }
+    };
+    Ok(Arc::new(res))
+}
+pub(super) fn item_map(
+    db: &impl HirDatabase,
+    source_root: SourceRootId,
+) -> Cancelable<Arc<ItemMap>> {
+    let start = Instant::now();
+    let module_tree = db.module_tree(source_root)?;
+    let input = module_tree
+        .modules()
+        .map(|id| {
+            let items = db.input_module_items(source_root, id)?;
+            Ok((id, items))
+        })
+        .collect::<Cancelable<FxHashMap<_, _>>>()?;
+    let resolver = Resolver {
+        db: db,
+        input: &input,
+        source_root,
+        module_tree,
+        result: ItemMap::default(),
+    };
+    let res = resolver.resolve()?;
+    let elapsed = start.elapsed();
+    log::info!("item_map: {:?}", elapsed);
+    Ok(Arc::new(res))
+}
diff --git a/crates/ra_lsp_server/src/caps.rs b/crates/ra_lsp_server/src/caps.rs
index bcf857fce..560f64989 100644
--- a/crates/ra_lsp_server/src/caps.rs
+++ b/crates/ra_lsp_server/src/caps.rs
@@ -19,7 +19,7 @@ pub fn server_capabilities() -> ServerCapabilities {
        hover_provider: Some(true),
        completion_provider: Some(CompletionOptions {
            resolve_provider: None,
-            trigger_characters: None,
+            trigger_characters: Some(vec![":".to_string()]),
        }),
        signature_help_provider: Some(SignatureHelpOptions {
            trigger_characters: Some(vec!["(".to_string(), ",".to_string(), ")".to_string()]),
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index e5a2449c2..28368787c 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -49,10 +49,9 @@ impl ConvWith for Position {
    type Output = TextUnit;
    fn conv_with(self, line_index: &LineIndex) -> TextUnit {
-        // TODO: UTF-16
        let line_col = LineCol {
            line: self.line as u32,
-            col: (self.character as u32).into(),
+            col_utf16: self.character as u32,
        };
        line_index.offset(line_col)
    }
@@ -64,8 +63,7 @@ impl ConvWith for TextUnit {
    fn conv_with(self, line_index: &LineIndex) -> Position {
        let line_col = line_index.line_col(self);
-        // TODO: UTF-16
+        Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16))
-        Position::new(u64::from(line_col.line), u64::from(u32::from(line_col.col)))
    }
 }
@@ -204,7 +202,7 @@ impl TryConvWith for SourceChange {
                    .unwrap_or(&[]);
                let line_col = translate_offset_with_edit(&*line_index, pos.offset, edits);
                let position =
-                    Position::new(u64::from(line_col.line), u64::from(u32::from(line_col.col)));
+                    Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16));
                Some(TextDocumentPositionParams {
                    text_document: TextDocumentIdentifier::new(pos.file_id.try_conv_with(world)?),
                    position,
@@ -247,12 +245,12 @@ fn translate_offset_with_edit(
    if in_edit_line_col.line == 0 {
        LineCol {
            line: edit_line_col.line,
-            col: edit_line_col.col + in_edit_line_col.col,
+            col_utf16: edit_line_col.col_utf16 + in_edit_line_col.col_utf16,
        }
    } else {
        LineCol {
            line: edit_line_col.line + in_edit_line_col.line,
-            col: in_edit_line_col.col,
+            col_utf16: in_edit_line_col.col_utf16,
        }
    }
 }
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs
index 26bcddd8e..8301a1044 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/ra_lsp_server/src/main.rs
@@ -65,27 +65,3 @@ fn main_inner() -> Result<()> {
    info!("... IO is down");
    Ok(())
 }
-/*
-                    (let ((backend (eglot-xref-backend)))
-                      (mapcar
-                       (lambda (xref)
-                         (let ((loc (xref-item-location xref)))
-                           (propertize
-                            (concat
-                             (when (xref-file-location-p loc)
-                               (with-slots (file line column) loc
-                                 (format "%s:%s:%s:"
-                                         (propertize (file-relative-name file)
-                                                     'face 'compilation-info)
-                                         (propertize (format "%s" line)
-                                                     'face 'compilation-line
-                                                     )
-                                         column)))
-                             (xref-item-summary xref))
-                            'xref xref)))
-                       (xref-backend-apropos backend "Analysis"))
-                      )
-*/
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index c872b0dc4..6d5622b15 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -9,7 +9,7 @@ use languageserver_types::{
    WorkspaceEdit, ParameterInformation, SignatureInformation, Hover, HoverContents,
 };
 use ra_analysis::{FileId, FoldKind, Query, RunnableKind, FilePosition};
-use ra_syntax::text_utils::contains_offset_nonstrict;
+use ra_syntax::{TextUnit, text_utils::contains_offset_nonstrict};
 use rustc_hash::FxHashMap;
 use serde_json::to_value;
@@ -381,6 +381,28 @@ pub fn handle_completion(
        let offset = params.position.conv_with(&line_index);
        FilePosition { file_id, offset }
    };
+    let completion_triggered_after_single_colon = {
+        let mut res = false;
+        if let Some(ctx) = params.context {
+            if ctx.trigger_character.unwrap_or_default() == ":" {
+                let source_file = world.analysis().file_syntax(position.file_id);
+                let syntax = source_file.syntax();
+                let text = syntax.text();
+                if let Some(next_char) = text.char_at(position.offset) {
+                    let diff = TextUnit::of_char(next_char) + TextUnit::of_char(':');
+                    let prev_char = position.offset - diff;
+                    if text.char_at(prev_char) != Some(':') {
+                        res = true;
+                    }
+                }
+            }
+        }
+        res
+    };
+    if completion_triggered_after_single_colon {
+        return Ok(None);
+    }
    let items = match world.analysis().completions(position)? {
        None => return Ok(None),
        Some(items) => items,
@@ -545,10 +567,13 @@ pub fn handle_rename(world: ServerWorld, params: RenameParams) -> Result<Option<
    let mut changes = HashMap::new();
    for r in refs {
        if let Ok(loc) = to_location(r.0, r.1, &world, &line_index) {
-            changes.entry(loc.uri).or_insert(Vec::new()).push(TextEdit {
+            changes
-                range: loc.range,
+                .entry(loc.uri)
-                new_text: params.new_name.clone(),
+                .or_insert_with(Vec::new)
-            });
+                .push(TextEdit {
+                    range: loc.range,
+                    new_text: params.new_name.clone(),
+                });
        }
    }
diff --git a/crates/ra_lsp_server/src/main_loop/mod.rs b/crates/ra_lsp_server/src/main_loop/mod.rs
index 78d93741a..36f08be2f 100644
--- a/crates/ra_lsp_server/src/main_loop/mod.rs
+++ b/crates/ra_lsp_server/src/main_loop/mod.rs
@@ -168,9 +168,35 @@ fn main_loop_inner(
                    let workspaces = vec![ws];
                    feedback(internal_mode, "workspace loaded", msg_sender);
                    for ws in workspaces.iter() {
-                        for pkg in ws.packages().filter(|pkg| !pkg.is_member(ws)) {
+                        // Add each library as constant input. If library is
-                            debug!("sending root, {}", pkg.root(ws).to_path_buf().display());
+                        // within the workspace, don't treat it as a library.
-                            fs_worker.send(pkg.root(ws).to_path_buf());
+                        //
+                        // HACK: If source roots are nested, pick the outer one.
+                        let mut roots = ws
+                            .packages()
+                            .filter(|pkg| !pkg.is_member(ws))
+                            .filter_map(|pkg| {
+                                let root = pkg.root(ws).to_path_buf();
+                                if root.starts_with(&ws_root) {
+                                    None
+                                } else {
+                                    Some(root)
+                                }
+                            })
+                            .collect::<Vec<_>>();
+                        roots.sort_by_key(|it| it.as_os_str().len());
+                        let unique = roots
+                            .iter()
+                            .enumerate()
+                            .filter(|&(idx, long)| {
+                                !roots[..idx].iter().any(|short| long.starts_with(short))
+                            })
+                            .map(|(_idx, root)| root);
+                        for root in unique {
+                            debug!("sending root, {}", root.display());
+                            fs_worker.send(root.to_owned());
                        }
                    }
                    state.set_workspaces(workspaces);
diff --git a/crates/ra_lsp_server/src/path_map.rs b/crates/ra_lsp_server/src/path_map.rs
index 87eabf9be..02e54629c 100644
--- a/crates/ra_lsp_server/src/path_map.rs
+++ b/crates/ra_lsp_server/src/path_map.rs
@@ -43,7 +43,7 @@ impl PathMap {
        (inserted, file_id)
    }
    pub fn get_id(&self, path: &Path) -> Option<FileId> {
-        self.path2id.get(path).map(|&id| id)
+        self.path2id.get(path).cloned()
    }
    pub fn get_path(&self, file_id: FileId) -> &Path {
        self.id2path.get(&file_id).unwrap().as_path()
@@ -79,6 +79,10 @@ impl FileResolver for PathMap {
        let path = normalize(&path);
        self.get_id(&path)
    }
+    fn debug_path(&self, file_id: FileId) -> Option<PathBuf> {
+        Some(self.get_path(file_id).to_owned())
+    }
 }
 fn normalize(path: &Path) -> PathBuf {
diff --git a/crates/ra_lsp_server/src/server_world.rs b/crates/ra_lsp_server/src/server_world.rs
index 3e7670fcc..12faeb93a 100644
--- a/crates/ra_lsp_server/src/server_world.rs
+++ b/crates/ra_lsp_server/src/server_world.rs
@@ -140,7 +140,7 @@ impl ServerWorldState {
        Ok(file_id)
    }
    pub fn set_workspaces(&mut self, ws: Vec<CargoWorkspace>) {
-        let mut crate_graph = CrateGraph::new();
+        let mut crate_graph = CrateGraph::default();
        ws.iter()
            .flat_map(|ws| {
                ws.packages()
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 2e9ae263a..bf056131e 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -372,6 +372,80 @@ impl<R: TreeRoot<RaTypes>> BreakExprNode<R> {
 impl<'a> BreakExpr<'a> {}
+// Byte
+#[derive(Debug, Clone, Copy,)]
+pub struct ByteNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type Byte<'a> = ByteNode<RefRoot<'a>>;
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ByteNode<R1>> for ByteNode<R2> {
+    fn eq(&self, other: &ByteNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ByteNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ByteNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+impl<'a> AstNode<'a> for Byte<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            BYTE => Some(Byte { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+impl<R: TreeRoot<RaTypes>> ByteNode<R> {
+    pub fn borrowed(&self) -> Byte {
+        ByteNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ByteNode {
+        ByteNode { syntax: self.syntax.owned() }
+    }
+}
+impl<'a> Byte<'a> {}
+// ByteString
+#[derive(Debug, Clone, Copy,)]
+pub struct ByteStringNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type ByteString<'a> = ByteStringNode<RefRoot<'a>>;
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ByteStringNode<R1>> for ByteStringNode<R2> {
+    fn eq(&self, other: &ByteStringNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ByteStringNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ByteStringNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+impl<'a> AstNode<'a> for ByteString<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            BYTE_STRING => Some(ByteString { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+impl<R: TreeRoot<RaTypes>> ByteStringNode<R> {
+    pub fn borrowed(&self) -> ByteString {
+        ByteStringNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ByteStringNode {
+        ByteStringNode { syntax: self.syntax.owned() }
+    }
+}
+impl<'a> ByteString<'a> {}
 // CallExpr
 #[derive(Debug, Clone, Copy,)]
 pub struct CallExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
diff --git a/crates/ra_syntax/src/ast/mod.rs b/crates/ra_syntax/src/ast/mod.rs
index f20714ede..91c67119f 100644
--- a/crates/ra_syntax/src/ast/mod.rs
+++ b/crates/ra_syntax/src/ast/mod.rs
@@ -134,6 +134,18 @@ impl<'a> Char<'a> {
    }
 }
+impl<'a> Byte<'a> {
+    pub fn text(&self) -> &SmolStr {
+        &self.syntax().leaf_text().unwrap()
+    }
+}
+impl<'a> ByteString<'a> {
+    pub fn text(&self) -> &SmolStr {
+        &self.syntax().leaf_text().unwrap()
+    }
+}
 impl<'a> String<'a> {
    pub fn text(&self) -> &SmolStr {
        &self.syntax().leaf_text().unwrap()
@@ -303,6 +315,12 @@ impl<'a> PathSegment<'a> {
    }
 }
+impl<'a> UseTree<'a> {
+    pub fn has_star(self) -> bool {
+        self.syntax().children().any(|it| it.kind() == STAR)
+    }
+}
 impl<'a> UseTreeList<'a> {
    pub fn parent_use_tree(self) -> UseTree<'a> {
        self.syntax()
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index c3184667e..53cd2118f 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -412,6 +412,8 @@ Grammar(
        "RangeExpr": (),
        "BinExpr": (),
        "String": (),
+        "Byte": (),
+        "ByteString": (),
        "Char": (),
        "Literal": (),
diff --git a/crates/ra_syntax/src/grammar/items/mod.rs b/crates/ra_syntax/src/grammar/items/mod.rs
index 06c6b5e6e..682266908 100644
--- a/crates/ra_syntax/src/grammar/items/mod.rs
+++ b/crates/ra_syntax/src/grammar/items/mod.rs
@@ -29,7 +29,7 @@ pub(super) enum ItemFlavor {
    Trait,
 }
-const ITEM_RECOVERY_SET: TokenSet = token_set![
+pub(super) const ITEM_RECOVERY_SET: TokenSet = token_set![
    FN_KW, STRUCT_KW, ENUM_KW, IMPL_KW, TRAIT_KW, CONST_KW, STATIC_KW, LET_KW, MOD_KW, PUB_KW,
    CRATE_KW
 ];
diff --git a/crates/ra_syntax/src/grammar/paths.rs b/crates/ra_syntax/src/grammar/paths.rs
index a35a339cc..33a11886c 100644
--- a/crates/ra_syntax/src/grammar/paths.rs
+++ b/crates/ra_syntax/src/grammar/paths.rs
@@ -78,7 +78,7 @@ fn path_segment(p: &mut Parser, mode: Mode, first: bool) {
            // use crate::foo;
            SELF_KW | SUPER_KW | CRATE_KW => p.bump(),
            _ => {
-                p.err_and_bump("expected identifier");
+                p.err_recover("expected identifier", items::ITEM_RECOVERY_SET);
            }
        };
    }
diff --git a/crates/ra_syntax/src/reparsing.rs b/crates/ra_syntax/src/reparsing.rs
index d48133166..ddcb8f6f6 100644
--- a/crates/ra_syntax/src/reparsing.rs
+++ b/crates/ra_syntax/src/reparsing.rs
@@ -186,8 +186,10 @@ mod tests {
    fn do_check<F>(before: &str, replace_with: &str, reparser: F)
    where
-        for<'a> F: Fn(SyntaxNodeRef<'a>, &AtomEdit)
+        for<'a> F: Fn(
-            -> Option<(SyntaxNodeRef<'a>, GreenNode, Vec<SyntaxError>)>,
+            SyntaxNodeRef<'a>,
+            &AtomEdit,
+        ) -> Option<(SyntaxNodeRef<'a>, GreenNode, Vec<SyntaxError>)>,
    {
        let (range, before) = extract_range(before);
        let after = replace_range(before.clone(), range, replace_with);
diff --git a/crates/ra_syntax/src/string_lexing.rs b/crates/ra_syntax/src/string_lexing.rs
deleted file mode 100644
index d613bb042..000000000
--- a/crates/ra_syntax/src/string_lexing.rs
+++ /dev/null
@@ -1,414 +0,0 @@
-use self::CharComponentKind::*;
-use rowan::{TextRange, TextUnit};
-pub fn parse_string_literal(src: &str) -> StringComponentIterator {
-    StringComponentIterator {
-        parser: Parser::new(src),
-        has_closing_quote: false,
-    }
-}
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub struct StringComponent {
-    pub range: TextRange,
-    pub kind: StringComponentKind,
-}
-impl StringComponent {
-    fn new(range: TextRange, kind: StringComponentKind) -> StringComponent {
-        StringComponent { range, kind }
-    }
-}
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub enum StringComponentKind {
-    IgnoreNewline,
-    Char(CharComponentKind),
-}
-pub struct StringComponentIterator<'a> {
-    parser: Parser<'a>,
-    pub has_closing_quote: bool,
-}
-impl<'a> Iterator for StringComponentIterator<'a> {
-    type Item = StringComponent;
-    fn next(&mut self) -> Option<StringComponent> {
-        if self.parser.pos == 0 {
-            assert!(
-                self.parser.advance() == '"',
-                "string literal should start with double quotes"
-            );
-        }
-        if let Some(component) = self.parser.parse_string_component() {
-            return Some(component);
-        }
-        // We get here when there are no char components left to parse
-        if self.parser.peek() == Some('"') {
-            self.parser.advance();
-            self.has_closing_quote = true;
-        }
-        assert!(
-            self.parser.peek() == None,
-            "string literal should leave no unparsed input: src = {}, pos = {}, length = {}",
-            self.parser.src,
-            self.parser.pos,
-            self.parser.src.len()
-        );
-        None
-    }
-}
-pub fn parse_char_literal(src: &str) -> CharComponentIterator {
-    CharComponentIterator {
-        parser: Parser::new(src),
-        has_closing_quote: false,
-    }
-}
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub struct CharComponent {
-    pub range: TextRange,
-    pub kind: CharComponentKind,
-}
-impl CharComponent {
-    fn new(range: TextRange, kind: CharComponentKind) -> CharComponent {
-        CharComponent { range, kind }
-    }
-}
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub enum CharComponentKind {
-    CodePoint,
-    AsciiEscape,
-    AsciiCodeEscape,
-    UnicodeEscape,
-}
-pub struct CharComponentIterator<'a> {
-    parser: Parser<'a>,
-    pub has_closing_quote: bool,
-}
-impl<'a> Iterator for CharComponentIterator<'a> {
-    type Item = CharComponent;
-    fn next(&mut self) -> Option<CharComponent> {
-        if self.parser.pos == 0 {
-            assert!(
-                self.parser.advance() == '\'',
-                "char literal should start with a quote"
-            );
-        }
-        if let Some(component) = self.parser.parse_char_component() {
-            return Some(component);
-        }
-        // We get here when there are no char components left to parse
-        if self.parser.peek() == Some('\'') {
-            self.parser.advance();
-            self.has_closing_quote = true;
-        }
-        assert!(
-            self.parser.peek() == None,
-            "char literal should leave no unparsed input: src = {}, pos = {}, length = {}",
-            self.parser.src,
-            self.parser.pos,
-            self.parser.src.len()
-        );
-        None
-    }
-}
-pub struct Parser<'a> {
-    src: &'a str,
-    pos: usize,
-}
-impl<'a> Parser<'a> {
-    pub fn new(src: &'a str) -> Parser<'a> {
-        Parser { src, pos: 0 }
-    }
-    // Utility methods
-    pub fn peek(&self) -> Option<char> {
-        if self.pos == self.src.len() {
-            return None;
-        }
-        self.src[self.pos..].chars().next()
-    }
-    pub fn advance(&mut self) -> char {
-        let next = self
-            .peek()
-            .expect("cannot advance if end of input is reached");
-        self.pos += next.len_utf8();
-        next
-    }
-    pub fn skip_whitespace(&mut self) {
-        while self.peek().map(|c| c.is_whitespace()) == Some(true) {
-            self.advance();
-        }
-    }
-    pub fn get_pos(&self) -> TextUnit {
-        (self.pos as u32).into()
-    }
-    // Char parsing methods
-    fn parse_unicode_escape(&mut self, start: TextUnit) -> CharComponent {
-        match self.peek() {
-            Some('{') => {
-                self.advance();
-                // Parse anything until we reach `}`
-                while let Some(next) = self.peek() {
-                    self.advance();
-                    if next == '}' {
-                        break;
-                    }
-                }
-                let end = self.get_pos();
-                CharComponent::new(TextRange::from_to(start, end), UnicodeEscape)
-            }
-            Some(_) | None => {
-                let end = self.get_pos();
-                CharComponent::new(TextRange::from_to(start, end), UnicodeEscape)
-            }
-        }
-    }
-    fn parse_ascii_code_escape(&mut self, start: TextUnit) -> CharComponent {
-        let code_start = self.get_pos();
-        while let Some(next) = self.peek() {
-            if next == '\'' || (self.get_pos() - code_start == 2.into()) {
-                break;
-            }
-            self.advance();
-        }
-        let end = self.get_pos();
-        CharComponent::new(TextRange::from_to(start, end), AsciiCodeEscape)
-    }
-    fn parse_escape(&mut self, start: TextUnit) -> CharComponent {
-        if self.peek().is_none() {
-            return CharComponent::new(TextRange::from_to(start, start), AsciiEscape);
-        }
-        let next = self.advance();
-        let end = self.get_pos();
-        let range = TextRange::from_to(start, end);
-        match next {
-            'x' => self.parse_ascii_code_escape(start),
-            'u' => self.parse_unicode_escape(start),
-            _ => CharComponent::new(range, AsciiEscape),
-        }
-    }
-    pub fn parse_char_component(&mut self) -> Option<CharComponent> {
-        let next = self.peek()?;
-        // Ignore character close
-        if next == '\'' {
-            return None;
-        }
-        let start = self.get_pos();
-        self.advance();
-        if next == '\\' {
-            Some(self.parse_escape(start))
-        } else {
-            let end = self.get_pos();
-            Some(CharComponent::new(
-                TextRange::from_to(start, end),
-                CodePoint,
-            ))
-        }
-    }
-    pub fn parse_ignore_newline(&mut self, start: TextUnit) -> Option<StringComponent> {
-        // In string literals, when a `\` occurs immediately before the newline, the `\`,
-        // the newline, and all whitespace at the beginning of the next line are ignored
-        match self.peek() {
-            Some('\n') | Some('\r') => {
-                self.skip_whitespace();
-                Some(StringComponent::new(
-                    TextRange::from_to(start, self.get_pos()),
-                    StringComponentKind::IgnoreNewline,
-                ))
-            }
-            _ => None,
-        }
-    }
-    pub fn parse_string_component(&mut self) -> Option<StringComponent> {
-        let next = self.peek()?;
-        // Ignore string close
-        if next == '"' {
-            return None;
-        }
-        let start = self.get_pos();
-        self.advance();
-        if next == '\\' {
-            // Strings can use `\` to ignore newlines, so we first try to parse one of those
-            // before falling back to parsing char escapes
-            self.parse_ignore_newline(start).or_else(|| {
-                let char_component = self.parse_escape(start);
-                Some(StringComponent::new(
-                    char_component.range,
-                    StringComponentKind::Char(char_component.kind),
-                ))
-            })
-        } else {
-            let end = self.get_pos();
-            Some(StringComponent::new(
-                TextRange::from_to(start, end),
-                StringComponentKind::Char(CodePoint),
-            ))
-        }
-    }
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn parse(src: &str) -> (bool, Vec<CharComponent>) {
-        let component_iterator = &mut super::parse_char_literal(src);
-        let components: Vec<_> = component_iterator.collect();
-        (component_iterator.has_closing_quote, components)
-    }
-    fn unclosed_char_component(src: &str) -> CharComponent {
-        let (has_closing_quote, components) = parse(src);
-        assert!(!has_closing_quote, "char should not have closing quote");
-        assert!(components.len() == 1);
-        components[0].clone()
-    }
-    fn closed_char_component(src: &str) -> CharComponent {
-        let (has_closing_quote, components) = parse(src);
-        assert!(has_closing_quote, "char should have closing quote");
-        assert!(
-            components.len() == 1,
-            "Literal: {}\nComponents: {:#?}",
-            src,
-            components
-        );
-        components[0].clone()
-    }
-    fn closed_char_components(src: &str) -> Vec<CharComponent> {
-        let (has_closing_quote, components) = parse(src);
-        assert!(has_closing_quote, "char should have closing quote");
-        components
-    }
-    fn range_closed(src: &str) -> TextRange {
-        TextRange::from_to(1.into(), (src.len() as u32 - 1).into())
-    }
-    fn range_unclosed(src: &str) -> TextRange {
-        TextRange::from_to(1.into(), (src.len() as u32).into())
-    }
-    #[test]
-    fn test_unicode_escapes() {
-        let unicode_escapes = &[r"{DEAD}", "{BEEF}", "{FF}", "{}", ""];
-        for escape in unicode_escapes {
-            let escape_sequence = format!(r"'\u{}'", escape);
-            let component = closed_char_component(&escape_sequence);
-            let expected_range = range_closed(&escape_sequence);
-            assert_eq!(component.kind, CharComponentKind::UnicodeEscape);
-            assert_eq!(component.range, expected_range);
-        }
-    }
-    #[test]
-    fn test_unicode_escapes_unclosed() {
-        let unicode_escapes = &["{DEAD", "{BEEF", "{FF"];
-        for escape in unicode_escapes {
-            let escape_sequence = format!(r"'\u{}'", escape);
-            let component = unclosed_char_component(&escape_sequence);
-            let expected_range = range_unclosed(&escape_sequence);
-            assert_eq!(component.kind, CharComponentKind::UnicodeEscape);
-            assert_eq!(component.range, expected_range);
-        }
-    }
-    #[test]
-    fn test_empty_char() {
-        let (has_closing_quote, components) = parse("''");
-        assert!(has_closing_quote, "char should have closing quote");
-        assert!(components.len() == 0);
-    }
-    #[test]
-    fn test_unclosed_char() {
-        let component = unclosed_char_component("'a");
-        assert!(component.kind == CodePoint);
-        assert!(component.range == TextRange::from_to(1.into(), 2.into()));
-    }
-    #[test]
-    fn test_digit_escapes() {
-        let literals = &[r"", r"5", r"55"];
-        for literal in literals {
-            let lit_text = format!(r"'\x{}'", literal);
-            let component = closed_char_component(&lit_text);
-            assert!(component.kind == CharComponentKind::AsciiCodeEscape);
-            assert!(component.range == range_closed(&lit_text));
-        }
-        // More than 2 digits starts a new codepoint
-        let components = closed_char_components(r"'\x555'");
-        assert!(components.len() == 2);
-        assert!(components[1].kind == CharComponentKind::CodePoint);
-    }
-    #[test]
-    fn test_ascii_escapes() {
-        let literals = &[
-            r"\'", "\\\"", // equivalent to \"
-            r"\n", r"\r", r"\t", r"\\", r"\0",
-        ];
-        for literal in literals {
-            let lit_text = format!("'{}'", literal);
-            let component = closed_char_component(&lit_text);
-            assert!(component.kind == CharComponentKind::AsciiEscape);
-            assert!(component.range == range_closed(&lit_text));
-        }
-    }
-    #[test]
-    fn test_no_escapes() {
-        let literals = &['"', 'n', 'r', 't', '0', 'x', 'u'];
-        for &literal in literals {
-            let lit_text = format!("'{}'", literal);
-            let component = closed_char_component(&lit_text);
-            assert!(component.kind == CharComponentKind::CodePoint);
-            assert!(component.range == range_closed(&lit_text));
-        }
-    }
-}
diff --git a/crates/ra_syntax/src/string_lexing/byte.rs b/crates/ra_syntax/src/string_lexing/byte.rs
new file mode 100644
index 000000000..24424349c
--- /dev/null
+++ b/crates/ra_syntax/src/string_lexing/byte.rs
@@ -0,0 +1,51 @@
+use super::parser::Parser;
+use super::CharComponent;
+pub fn parse_byte_literal(src: &str) -> ByteComponentIterator {
+    ByteComponentIterator {
+        parser: Parser::new(src),
+        has_closing_quote: false,
+    }
+}
+pub struct ByteComponentIterator<'a> {
+    parser: Parser<'a>,
+    pub has_closing_quote: bool,
+}
+impl<'a> Iterator for ByteComponentIterator<'a> {
+    type Item = CharComponent;
+    fn next(&mut self) -> Option<CharComponent> {
+        if self.parser.pos == 0 {
+            assert!(
+                self.parser.advance() == 'b',
+                "Byte literal should start with a `b`"
+            );
+            assert!(
+                self.parser.advance() == '\'',
+                "Byte literal should start with a `b`, followed by a quote"
+            );
+        }
+        if let Some(component) = self.parser.parse_char_component() {
+            return Some(component);
+        }
+        // We get here when there are no char components left to parse
+        if self.parser.peek() == Some('\'') {
+            self.parser.advance();
+            self.has_closing_quote = true;
+        }
+        assert!(
+            self.parser.peek() == None,
+            "byte literal should leave no unparsed input: src = {}, pos = {}, length = {}",
+            self.parser.src,
+            self.parser.pos,
+            self.parser.src.len()
+        );
+        None
+    }
+}
diff --git a/crates/ra_syntax/src/string_lexing/byte_string.rs b/crates/ra_syntax/src/string_lexing/byte_string.rs
new file mode 100644
index 000000000..5b6dda760
--- /dev/null
+++ b/crates/ra_syntax/src/string_lexing/byte_string.rs
@@ -0,0 +1,51 @@
+use super::parser::Parser;
+use super::StringComponent;
+pub fn parse_byte_string_literal(src: &str) -> ByteStringComponentIterator {
+    ByteStringComponentIterator {
+        parser: Parser::new(src),
+        has_closing_quote: false,
+    }
+}
+pub struct ByteStringComponentIterator<'a> {
+    parser: Parser<'a>,
+    pub has_closing_quote: bool,
+}
+impl<'a> Iterator for ByteStringComponentIterator<'a> {
+    type Item = StringComponent;
+    fn next(&mut self) -> Option<StringComponent> {
+        if self.parser.pos == 0 {
+            assert!(
+                self.parser.advance() == 'b',
+                "byte string literal should start with a `b`"
+            );
+            assert!(
+                self.parser.advance() == '"',
+                "byte string literal should start with a `b`, followed by double quotes"
+            );
+        }
+        if let Some(component) = self.parser.parse_string_component() {
+            return Some(component);
+        }
+        // We get here when there are no char components left to parse
+        if self.parser.peek() == Some('"') {
+            self.parser.advance();
+            self.has_closing_quote = true;
+        }
+        assert!(
+            self.parser.peek() == None,
+            "byte string literal should leave no unparsed input: src = {}, pos = {}, length = {}",
+            self.parser.src,
+            self.parser.pos,
+            self.parser.src.len()
+        );
+        None
+    }
+}
diff --git a/crates/ra_syntax/src/string_lexing/char.rs b/crates/ra_syntax/src/string_lexing/char.rs
new file mode 100644
index 000000000..885c03b14
--- /dev/null
+++ b/crates/ra_syntax/src/string_lexing/char.rs
@@ -0,0 +1,176 @@
+use super::parser::Parser;
+use super::CharComponent;
+pub fn parse_char_literal(src: &str) -> CharComponentIterator {
+    CharComponentIterator {
+        parser: Parser::new(src),
+        has_closing_quote: false,
+    }
+}
+pub struct CharComponentIterator<'a> {
+    parser: Parser<'a>,
+    pub has_closing_quote: bool,
+}
+impl<'a> Iterator for CharComponentIterator<'a> {
+    type Item = CharComponent;
+    fn next(&mut self) -> Option<CharComponent> {
+        if self.parser.pos == 0 {
+            assert!(
+                self.parser.advance() == '\'',
+                "char literal should start with a quote"
+            );
+        }
+        if let Some(component) = self.parser.parse_char_component() {
+            return Some(component);
+        }
+        // We get here when there are no char components left to parse
+        if self.parser.peek() == Some('\'') {
+            self.parser.advance();
+            self.has_closing_quote = true;
+        }
+        assert!(
+            self.parser.peek() == None,
+            "char literal should leave no unparsed input: src = {}, pos = {}, length = {}",
+            self.parser.src,
+            self.parser.pos,
+            self.parser.src.len()
+        );
+        None
+    }
+}
+#[cfg(test)]
+mod tests {
+    use rowan::TextRange;
+    use crate::string_lexing::{
+        CharComponent,
+        CharComponentKind::*,
+};
+    fn parse(src: &str) -> (bool, Vec<CharComponent>) {
+        let component_iterator = &mut super::parse_char_literal(src);
+        let components: Vec<_> = component_iterator.collect();
+        (component_iterator.has_closing_quote, components)
+    }
+    fn unclosed_char_component(src: &str) -> CharComponent {
+        let (has_closing_quote, components) = parse(src);
+        assert!(!has_closing_quote, "char should not have closing quote");
+        assert!(components.len() == 1);
+        components[0].clone()
+    }
+    fn closed_char_component(src: &str) -> CharComponent {
+        let (has_closing_quote, components) = parse(src);
+        assert!(has_closing_quote, "char should have closing quote");
+        assert!(
+            components.len() == 1,
+            "Literal: {}\nComponents: {:#?}",
+            src,
+            components
+        );
+        components[0].clone()
+    }
+    fn closed_char_components(src: &str) -> Vec<CharComponent> {
+        let (has_closing_quote, components) = parse(src);
+        assert!(has_closing_quote, "char should have closing quote");
+        components
+    }
+    fn range_closed(src: &str) -> TextRange {
+        TextRange::from_to(1.into(), (src.len() as u32 - 1).into())
+    }
+    fn range_unclosed(src: &str) -> TextRange {
+        TextRange::from_to(1.into(), (src.len() as u32).into())
+    }
+    #[test]
+    fn test_unicode_escapes() {
+        let unicode_escapes = &[r"{DEAD}", "{BEEF}", "{FF}", "{}", ""];
+        for escape in unicode_escapes {
+            let escape_sequence = format!(r"'\u{}'", escape);
+            let component = closed_char_component(&escape_sequence);
+            let expected_range = range_closed(&escape_sequence);
+            assert_eq!(component.kind, UnicodeEscape);
+            assert_eq!(component.range, expected_range);
+        }
+    }
+    #[test]
+    fn test_unicode_escapes_unclosed() {
+        let unicode_escapes = &["{DEAD", "{BEEF", "{FF"];
+        for escape in unicode_escapes {
+            let escape_sequence = format!(r"'\u{}'", escape);
+            let component = unclosed_char_component(&escape_sequence);
+            let expected_range = range_unclosed(&escape_sequence);
+            assert_eq!(component.kind, UnicodeEscape);
+            assert_eq!(component.range, expected_range);
+        }
+    }
+    #[test]
+    fn test_empty_char() {
+        let (has_closing_quote, components) = parse("''");
+        assert!(has_closing_quote, "char should have closing quote");
+        assert!(components.len() == 0);
+    }
+    #[test]
+    fn test_unclosed_char() {
+        let component = unclosed_char_component("'a");
+        assert!(component.kind == CodePoint);
+        assert!(component.range == TextRange::from_to(1.into(), 2.into()));
+    }
+    #[test]
+    fn test_digit_escapes() {
+        let literals = &[r"", r"5", r"55"];
+        for literal in literals {
+            let lit_text = format!(r"'\x{}'", literal);
+            let component = closed_char_component(&lit_text);
+            assert!(component.kind == AsciiCodeEscape);
+            assert!(component.range == range_closed(&lit_text));
+        }
+        // More than 2 digits starts a new codepoint
+        let components = closed_char_components(r"'\x555'");
+        assert!(components.len() == 2);
+        assert!(components[1].kind == CodePoint);
+    }
+    #[test]
+    fn test_ascii_escapes() {
+        let literals = &[
+            r"\'", "\\\"", // equivalent to \"
+            r"\n", r"\r", r"\t", r"\\", r"\0",
+        ];
+        for literal in literals {
+            let lit_text = format!("'{}'", literal);
+            let component = closed_char_component(&lit_text);
+            assert!(component.kind == AsciiEscape);
+            assert!(component.range == range_closed(&lit_text));
+        }
+    }
+    #[test]
+    fn test_no_escapes() {
+        let literals = &['"', 'n', 'r', 't', '0', 'x', 'u'];
+        for &literal in literals {
+            let lit_text = format!("'{}'", literal);
+            let component = closed_char_component(&lit_text);
+            assert!(component.kind == CodePoint);
+            assert!(component.range == range_closed(&lit_text));
+        }
+    }
+}
diff --git a/crates/ra_syntax/src/string_lexing/mod.rs b/crates/ra_syntax/src/string_lexing/mod.rs
new file mode 100644
index 000000000..94853331f
--- /dev/null
+++ b/crates/ra_syntax/src/string_lexing/mod.rs
@@ -0,0 +1,13 @@
+mod parser;
+mod byte;
+mod byte_string;
+mod char;
+mod string;
+pub use self::{
+    byte::parse_byte_literal,
+    byte_string::parse_byte_string_literal,
+    char::parse_char_literal,
+    parser::{CharComponent, CharComponentKind, StringComponent, StringComponentKind},
+    string::parse_string_literal,
+};
diff --git a/crates/ra_syntax/src/string_lexing/parser.rs b/crates/ra_syntax/src/string_lexing/parser.rs
new file mode 100644
index 000000000..4a6d5bc93
--- /dev/null
+++ b/crates/ra_syntax/src/string_lexing/parser.rs
@@ -0,0 +1,201 @@
+use rowan::{TextRange, TextUnit};
+use self::CharComponentKind::*;
+pub struct Parser<'a> {
+    pub(super) src: &'a str,
+    pub(super) pos: usize,
+}
+impl<'a> Parser<'a> {
+    pub fn new(src: &'a str) -> Parser<'a> {
+        Parser { src, pos: 0 }
+    }
+    // Utility methods
+    pub fn peek(&self) -> Option<char> {
+        if self.pos == self.src.len() {
+            return None;
+        }
+        self.src[self.pos..].chars().next()
+    }
+    pub fn advance(&mut self) -> char {
+        let next = self
+            .peek()
+            .expect("cannot advance if end of input is reached");
+        self.pos += next.len_utf8();
+        next
+    }
+    pub fn skip_whitespace(&mut self) {
+        while self.peek().map(|c| c.is_whitespace()) == Some(true) {
+            self.advance();
+        }
+    }
+    pub fn get_pos(&self) -> TextUnit {
+        (self.pos as u32).into()
+    }
+    // Char parsing methods
+    fn parse_unicode_escape(&mut self, start: TextUnit) -> CharComponent {
+        match self.peek() {
+            Some('{') => {
+                self.advance();
+                // Parse anything until we reach `}`
+                while let Some(next) = self.peek() {
+                    self.advance();
+                    if next == '}' {
+                        break;
+                    }
+                }
+                let end = self.get_pos();
+                CharComponent::new(TextRange::from_to(start, end), UnicodeEscape)
+            }
+            Some(_) | None => {
+                let end = self.get_pos();
+                CharComponent::new(TextRange::from_to(start, end), UnicodeEscape)
+            }
+        }
+    }
+    fn parse_ascii_code_escape(&mut self, start: TextUnit) -> CharComponent {
+        let code_start = self.get_pos();
+        while let Some(next) = self.peek() {
+            if next == '\'' || (self.get_pos() - code_start == 2.into()) {
+                break;
+            }
+            self.advance();
+        }
+        let end = self.get_pos();
+        CharComponent::new(TextRange::from_to(start, end), AsciiCodeEscape)
+    }
+    fn parse_escape(&mut self, start: TextUnit) -> CharComponent {
+        if self.peek().is_none() {
+            return CharComponent::new(TextRange::from_to(start, start), AsciiEscape);
+        }
+        let next = self.advance();
+        let end = self.get_pos();
+        let range = TextRange::from_to(start, end);
+        match next {
+            'x' => self.parse_ascii_code_escape(start),
+            'u' => self.parse_unicode_escape(start),
+            _ => CharComponent::new(range, AsciiEscape),
+        }
+    }
+    pub fn parse_char_component(&mut self) -> Option<CharComponent> {
+        let next = self.peek()?;
+        // Ignore character close
+        if next == '\'' {
+            return None;
+        }
+        let start = self.get_pos();
+        self.advance();
+        if next == '\\' {
+            Some(self.parse_escape(start))
+        } else {
+            let end = self.get_pos();
+            Some(CharComponent::new(
+                TextRange::from_to(start, end),
+                CodePoint,
+            ))
+        }
+    }
+    pub fn parse_ignore_newline(&mut self, start: TextUnit) -> Option<StringComponent> {
+        // In string literals, when a `\` occurs immediately before the newline, the `\`,
+        // the newline, and all whitespace at the beginning of the next line are ignored
+        match self.peek() {
+            Some('\n') | Some('\r') => {
+                self.skip_whitespace();
+                Some(StringComponent::new(
+                    TextRange::from_to(start, self.get_pos()),
+                    StringComponentKind::IgnoreNewline,
+                ))
+            }
+            _ => None,
+        }
+    }
+    pub fn parse_string_component(&mut self) -> Option<StringComponent> {
+        let next = self.peek()?;
+        // Ignore string close
+        if next == '"' {
+            return None;
+        }
+        let start = self.get_pos();
+        self.advance();
+        if next == '\\' {
+            // Strings can use `\` to ignore newlines, so we first try to parse one of those
+            // before falling back to parsing char escapes
+            self.parse_ignore_newline(start).or_else(|| {
+                let char_component = self.parse_escape(start);
+                Some(StringComponent::new(
+                    char_component.range,
+                    StringComponentKind::Char(char_component.kind),
+                ))
+            })
+        } else {
+            let end = self.get_pos();
+            Some(StringComponent::new(
+                TextRange::from_to(start, end),
+                StringComponentKind::Char(CodePoint),
+            ))
+        }
+    }
+}
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub struct StringComponent {
+    pub range: TextRange,
+    pub kind: StringComponentKind,
+}
+impl StringComponent {
+    fn new(range: TextRange, kind: StringComponentKind) -> StringComponent {
+        StringComponent { range, kind }
+    }
+}
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub enum StringComponentKind {
+    IgnoreNewline,
+    Char(CharComponentKind),
+}
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub struct CharComponent {
+    pub range: TextRange,
+    pub kind: CharComponentKind,
+}
+impl CharComponent {
+    fn new(range: TextRange, kind: CharComponentKind) -> CharComponent {
+        CharComponent { range, kind }
+    }
+}
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub enum CharComponentKind {
+    CodePoint,
+    AsciiEscape,
+    AsciiCodeEscape,
+    UnicodeEscape,
+}
diff --git a/crates/ra_syntax/src/string_lexing/string.rs b/crates/ra_syntax/src/string_lexing/string.rs
new file mode 100644
index 000000000..1b23029c6
--- /dev/null
+++ b/crates/ra_syntax/src/string_lexing/string.rs
@@ -0,0 +1,46 @@
+use super::parser::Parser;
+use super::StringComponent;
+pub fn parse_string_literal(src: &str) -> StringComponentIterator {
+    StringComponentIterator {
+        parser: Parser::new(src),
+        has_closing_quote: false,
+    }
+}
+pub struct StringComponentIterator<'a> {
+    parser: Parser<'a>,
+    pub has_closing_quote: bool,
+}
+impl<'a> Iterator for StringComponentIterator<'a> {
+    type Item = StringComponent;
+    fn next(&mut self) -> Option<StringComponent> {
+        if self.parser.pos == 0 {
+            assert!(
+                self.parser.advance() == '"',
+                "string literal should start with double quotes"
+            );
+        }
+        if let Some(component) = self.parser.parse_string_component() {
+            return Some(component);
+        }
+        // We get here when there are no char components left to parse
+        if self.parser.peek() == Some('"') {
+            self.parser.advance();
+            self.has_closing_quote = true;
+        }
+        assert!(
+            self.parser.peek() == None,
+            "string literal should leave no unparsed input: src = {}, pos = {}, length = {}",
+            self.parser.src,
+            self.parser.pos,
+            self.parser.src.len()
+        );
+        None
+    }
+}
diff --git a/crates/ra_syntax/src/validation/byte.rs b/crates/ra_syntax/src/validation/byte.rs
new file mode 100644
index 000000000..43c0d7edd
--- /dev/null
+++ b/crates/ra_syntax/src/validation/byte.rs
@@ -0,0 +1,211 @@
+//! Validation of byte literals
+use crate::{
+    ast::{self, AstNode},
+    string_lexing::{self, CharComponentKind},
+    TextRange,
+    validation::char,
+    yellow::{
+        SyntaxError,
+        SyntaxErrorKind::*,
+    },
+};
+pub(super) fn validate_byte_node(node: ast::Byte, errors: &mut Vec<SyntaxError>) {
+    let literal_text = node.text();
+    let literal_range = node.syntax().range();
+    let mut components = string_lexing::parse_byte_literal(literal_text);
+    let mut len = 0;
+    for component in &mut components {
+        len += 1;
+        let text = &literal_text[component.range];
+        let range = component.range + literal_range.start();
+        validate_byte_component(text, component.kind, range, errors);
+    }
+    if !components.has_closing_quote {
+        errors.push(SyntaxError::new(UnclosedByte, literal_range));
+    }
+    if len == 0 {
+        errors.push(SyntaxError::new(EmptyByte, literal_range));
+    }
+    if len > 1 {
+        errors.push(SyntaxError::new(OverlongByte, literal_range));
+    }
+}
+pub(super) fn validate_byte_component(
+    text: &str,
+    kind: CharComponentKind,
+    range: TextRange,
+    errors: &mut Vec<SyntaxError>,
+) {
+    use self::CharComponentKind::*;
+    match kind {
+        AsciiEscape => validate_byte_escape(text, range, errors),
+        AsciiCodeEscape => validate_byte_code_escape(text, range, errors),
+        UnicodeEscape => errors.push(SyntaxError::new(UnicodeEscapeForbidden, range)),
+        CodePoint => {
+            let c = text
+                .chars()
+                .next()
+                .expect("Code points should be one character long");
+            // These bytes must always be escaped
+            if c == '\t' || c == '\r' || c == '\n' {
+                errors.push(SyntaxError::new(UnescapedByte, range));
+            }
+            // Only ASCII bytes are allowed
+            if c > 0x7F as char {
+                errors.push(SyntaxError::new(ByteOutOfRange, range));
+            }
+        }
+    }
+}
+fn validate_byte_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
+    if text.len() == 1 {
+        // Escape sequence consists only of leading `\`
+        errors.push(SyntaxError::new(EmptyByteEscape, range));
+    } else {
+        let escape_code = text.chars().skip(1).next().unwrap();
+        if !char::is_ascii_escape(escape_code) {
+            errors.push(SyntaxError::new(InvalidByteEscape, range));
+        }
+    }
+}
+fn validate_byte_code_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
+    // A ByteCodeEscape has 4 chars, example: `\xDD`
+    if text.len() < 4 {
+        errors.push(SyntaxError::new(TooShortByteCodeEscape, range));
+    } else {
+        assert!(
+            text.chars().count() == 4,
+            "ByteCodeEscape cannot be longer than 4 chars"
+        );
+        if u8::from_str_radix(&text[2..], 16).is_err() {
+            errors.push(SyntaxError::new(MalformedByteCodeEscape, range));
+        }
+    }
+}
+#[cfg(test)]
+mod test {
+    use crate::SourceFileNode;
+    fn build_file(literal: &str) -> SourceFileNode {
+        let src = format!("const C: u8 = b'{}';", literal);
+        SourceFileNode::parse(&src)
+    }
+    fn assert_valid_byte(literal: &str) {
+        let file = build_file(literal);
+        assert!(
+            file.errors().len() == 0,
+            "Errors for literal '{}': {:?}",
+            literal,
+            file.errors()
+        );
+    }
+    fn assert_invalid_byte(literal: &str) {
+        let file = build_file(literal);
+        assert!(file.errors().len() > 0);
+    }
+    #[test]
+    fn test_ansi_codepoints() {
+        for byte in 0..128 {
+            match byte {
+                b'\n' | b'\r' | b'\t' => assert_invalid_byte(&(byte as char).to_string()),
+                b'\'' | b'\\' => { /* Ignore character close and backslash */ }
+                _ => assert_valid_byte(&(byte as char).to_string()),
+            }
+        }
+        for byte in 128..=255u8 {
+            assert_invalid_byte(&(byte as char).to_string());
+        }
+    }
+    #[test]
+    fn test_unicode_codepoints() {
+        let invalid = ["Ƒ", "バ", "メ", "﷽"];
+        for c in &invalid {
+            assert_invalid_byte(c);
+        }
+    }
+    #[test]
+    fn test_unicode_multiple_codepoints() {
+        let invalid = ["नी", "👨‍👨‍"];
+        for c in &invalid {
+            assert_invalid_byte(c);
+        }
+    }
+    #[test]
+    fn test_valid_byte_escape() {
+        let valid = [r"\'", "\"", "\\\\", "\\\"", r"\n", r"\r", r"\t", r"\0"];
+        for c in &valid {
+            assert_valid_byte(c);
+        }
+    }
+    #[test]
+    fn test_invalid_byte_escape() {
+        let invalid = [r"\a", r"\?", r"\"];
+        for c in &invalid {
+            assert_invalid_byte(c);
+        }
+    }
+    #[test]
+    fn test_valid_byte_code_escape() {
+        let valid = [r"\x00", r"\x7F", r"\x55", r"\xF0"];
+        for c in &valid {
+            assert_valid_byte(c);
+        }
+    }
+    #[test]
+    fn test_invalid_byte_code_escape() {
+        let invalid = [r"\x", r"\x7"];
+        for c in &invalid {
+            assert_invalid_byte(c);
+        }
+    }
+    #[test]
+    fn test_invalid_unicode_escape() {
+        let well_formed = [
+            r"\u{FF}",
+            r"\u{0}",
+            r"\u{F}",
+            r"\u{10FFFF}",
+            r"\u{1_0__FF___FF_____}",
+        ];
+        for c in &well_formed {
+            assert_invalid_byte(c);
+        }
+        let invalid = [
+            r"\u",
+            r"\u{}",
+            r"\u{",
+            r"\u{FF",
+            r"\u{FFFFFF}",
+            r"\u{_F}",
+            r"\u{00FFFFF}",
+            r"\u{110000}",
+        ];
+        for c in &invalid {
+            assert_invalid_byte(c);
+        }
+    }
+}
diff --git a/crates/ra_syntax/src/validation/byte_string.rs b/crates/ra_syntax/src/validation/byte_string.rs
new file mode 100644
index 000000000..7b830e97c
--- /dev/null
+++ b/crates/ra_syntax/src/validation/byte_string.rs
@@ -0,0 +1,178 @@
+use crate::{
+    ast::{self, AstNode},
+    string_lexing::{self, StringComponentKind},
+    yellow::{
+        SyntaxError,
+        SyntaxErrorKind::*,
+    },
+};
+use super::byte;
+pub(crate) fn validate_byte_string_node(node: ast::ByteString, errors: &mut Vec<SyntaxError>) {
+    let literal_text = node.text();
+    let literal_range = node.syntax().range();
+    let mut components = string_lexing::parse_byte_string_literal(literal_text);
+    for component in &mut components {
+        let range = component.range + literal_range.start();
+        match component.kind {
+            StringComponentKind::Char(kind) => {
+                // Chars must escape \t, \n and \r codepoints, but strings don't
+                let text = &literal_text[component.range];
+                match text {
+                    "\t" | "\n" | "\r" => { /* always valid */ }
+                    _ => byte::validate_byte_component(text, kind, range, errors),
+                }
+            }
+            StringComponentKind::IgnoreNewline => { /* always valid */ }
+        }
+    }
+    if !components.has_closing_quote {
+        errors.push(SyntaxError::new(UnclosedString, literal_range));
+    }
+}
+#[cfg(test)]
+mod test {
+    use crate::SourceFileNode;
+    fn build_file(literal: &str) -> SourceFileNode {
+        let src = format!(r#"const S: &'static [u8] = b"{}";"#, literal);
+        println!("Source: {}", src);
+        SourceFileNode::parse(&src)
+    }
+    fn assert_valid_str(literal: &str) {
+        let file = build_file(literal);
+        assert!(
+            file.errors().len() == 0,
+            "Errors for literal '{}': {:?}",
+            literal,
+            file.errors()
+        );
+    }
+    fn assert_invalid_str(literal: &str) {
+        let file = build_file(literal);
+        assert!(file.errors().len() > 0);
+    }
+    #[test]
+    fn test_ansi_codepoints() {
+        for byte in 0..128 {
+            match byte {
+                b'\"' | b'\\' => { /* Ignore string close and backslash */ }
+                _ => assert_valid_str(&(byte as char).to_string()),
+            }
+        }
+        for byte in 128..=255u8 {
+            assert_invalid_str(&(byte as char).to_string());
+        }
+    }
+    #[test]
+    fn test_unicode_codepoints() {
+        let invalid = ["Ƒ", "バ", "メ", "﷽"];
+        for c in &invalid {
+            assert_invalid_str(c);
+        }
+    }
+    #[test]
+    fn test_unicode_multiple_codepoints() {
+        let invalid = ["नी", "👨‍👨‍"];
+        for c in &invalid {
+            assert_invalid_str(c);
+        }
+    }
+    #[test]
+    fn test_valid_ascii_escape() {
+        let valid = [r"\'", r#"\""#, r"\\", r"\n", r"\r", r"\t", r"\0", "a", "b"];
+        for c in &valid {
+            assert_valid_str(c);
+        }
+    }
+    #[test]
+    fn test_invalid_ascii_escape() {
+        let invalid = [r"\a", r"\?", r"\"];
+        for c in &invalid {
+            assert_invalid_str(c);
+        }
+    }
+    #[test]
+    fn test_valid_ascii_code_escape() {
+        let valid = [r"\x00", r"\x7F", r"\x55", r"\xF0"];
+        for c in &valid {
+            assert_valid_str(c);
+        }
+    }
+    #[test]
+    fn test_invalid_ascii_code_escape() {
+        let invalid = [r"\x", r"\x7"];
+        for c in &invalid {
+            assert_invalid_str(c);
+        }
+    }
+    #[test]
+    fn test_invalid_unicode_escape() {
+        let well_formed = [
+            r"\u{FF}",
+            r"\u{0}",
+            r"\u{F}",
+            r"\u{10FFFF}",
+            r"\u{1_0__FF___FF_____}",
+        ];
+        for c in &well_formed {
+            assert_invalid_str(c);
+        }
+        let invalid = [
+            r"\u",
+            r"\u{}",
+            r"\u{",
+            r"\u{FF",
+            r"\u{FFFFFF}",
+            r"\u{_F}",
+            r"\u{00FFFFF}",
+            r"\u{110000}",
+        ];
+        for c in &invalid {
+            assert_invalid_str(c);
+        }
+    }
+    #[test]
+    fn test_mixed_invalid() {
+        assert_invalid_str(
+            r"This is the tale of a string
+with a newline in between, some emoji (👨‍👨‍) here and there,
+unicode escapes like this: \u{1FFBB} and weird stuff like
+this ﷽",
+        );
+    }
+    #[test]
+    fn test_mixed_valid() {
+        assert_valid_str(
+            r"This is the tale of a string
+with a newline in between, no emoji at all,
+nor unicode escapes or weird stuff",
+        );
+    }
+    #[test]
+    fn test_ignore_newline() {
+        assert_valid_str(
+            "Hello \
+             World",
+        );
+    }
+}
diff --git a/crates/ra_syntax/src/validation/char.rs b/crates/ra_syntax/src/validation/char.rs
index 63f9bad24..4728c85e6 100644
--- a/crates/ra_syntax/src/validation/char.rs
+++ b/crates/ra_syntax/src/validation/char.rs
@@ -1,3 +1,5 @@
+//! Validation of char literals
 use std::u32;
 use arrayvec::ArrayString;
@@ -12,7 +14,7 @@ use crate::{
    },
 };
-pub(crate) fn validate_char_node(node: ast::Char, errors: &mut Vec<SyntaxError>) {
+pub(super) fn validate_char_node(node: ast::Char, errors: &mut Vec<SyntaxError>) {
    let literal_text = node.text();
    let literal_range = node.syntax().range();
    let mut components = string_lexing::parse_char_literal(literal_text);
@@ -37,7 +39,7 @@ pub(crate) fn validate_char_node(node: ast::Char, errors: &mut Vec<SyntaxError>)
    }
 }
-pub(crate) fn validate_char_component(
+pub(super) fn validate_char_component(
    text: &str,
    kind: CharComponentKind,
    range: TextRange,
@@ -46,109 +48,115 @@ pub(crate) fn validate_char_component(
    // Validate escapes
    use self::CharComponentKind::*;
    match kind {
-        AsciiEscape => {
+        AsciiEscape => validate_ascii_escape(text, range, errors),
-            if text.len() == 1 {
+        AsciiCodeEscape => validate_ascii_code_escape(text, range, errors),
-                // Escape sequence consists only of leading `\`
+        UnicodeEscape => validate_unicode_escape(text, range, errors),
-                errors.push(SyntaxError::new(EmptyAsciiEscape, range));
+        CodePoint => {
-            } else {
+            // These code points must always be escaped
-                let escape_code = text.chars().skip(1).next().unwrap();
+            if text == "\t" || text == "\r" || text == "\n" {
-                if !is_ascii_escape(escape_code) {
+                errors.push(SyntaxError::new(UnescapedCodepoint, range));
-                    errors.push(SyntaxError::new(InvalidAsciiEscape, range));
-                }
            }
        }
-        AsciiCodeEscape => {
+    }
-            // An AsciiCodeEscape has 4 chars, example: `\xDD`
+}
-            if text.len() < 4 {
-                errors.push(SyntaxError::new(TooShortAsciiCodeEscape, range));
+fn validate_ascii_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
-            } else {
+    if text.len() == 1 {
-                assert!(
+        // Escape sequence consists only of leading `\`
-                    text.chars().count() == 4,
+        errors.push(SyntaxError::new(EmptyAsciiEscape, range));
-                    "AsciiCodeEscape cannot be longer than 4 chars"
+    } else {
-                );
+        let escape_code = text.chars().skip(1).next().unwrap();
+        if !is_ascii_escape(escape_code) {
-                match u8::from_str_radix(&text[2..], 16) {
+            errors.push(SyntaxError::new(InvalidAsciiEscape, range));
-                    Ok(code) if code < 128 => { /* Escape code is valid */ }
-                    Ok(_) => errors.push(SyntaxError::new(AsciiCodeEscapeOutOfRange, range)),
-                    Err(_) => errors.push(SyntaxError::new(MalformedAsciiCodeEscape, range)),
-                }
-            }
        }
-        UnicodeEscape => {
+    }
-            assert!(&text[..2] == "\\u", "UnicodeEscape always starts with \\u");
+}
-            if text.len() == 2 {
+pub(super) fn is_ascii_escape(code: char) -> bool {
-                // No starting `{`
+    match code {
-                errors.push(SyntaxError::new(MalformedUnicodeEscape, range));
+        '\\' | '\'' | '"' | 'n' | 'r' | 't' | '0' => true,
-                return;
+        _ => false,
-            }
+    }
+}
-            if text.len() == 3 {
+fn validate_ascii_code_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
-                // Only starting `{`
+    // An AsciiCodeEscape has 4 chars, example: `\xDD`
-                errors.push(SyntaxError::new(UnclosedUnicodeEscape, range));
+    if text.len() < 4 {
-                return;
+        errors.push(SyntaxError::new(TooShortAsciiCodeEscape, range));
-            }
+    } else {
+        assert!(
+            text.chars().count() == 4,
+            "AsciiCodeEscape cannot be longer than 4 chars"
+        );
-            let mut code = ArrayString::<[_; 6]>::new();
+        match u8::from_str_radix(&text[2..], 16) {
-            let mut closed = false;
+            Ok(code) if code < 128 => { /* Escape code is valid */ }
-            for c in text[3..].chars() {
+            Ok(_) => errors.push(SyntaxError::new(AsciiCodeEscapeOutOfRange, range)),
-                assert!(!closed, "no characters after escape is closed");
+            Err(_) => errors.push(SyntaxError::new(MalformedAsciiCodeEscape, range)),
+        }
-                if c.is_digit(16) {
+    }
-                    if code.len() == 6 {
+}
-                        errors.push(SyntaxError::new(OverlongUnicodeEscape, range));
-                        return;
-                    }
-                    code.push(c);
-                } else if c == '_' {
-                    // Reject leading _
-                    if code.len() == 0 {
-                        errors.push(SyntaxError::new(MalformedUnicodeEscape, range));
-                        return;
-                    }
-                } else if c == '}' {
-                    closed = true;
-                } else {
-                    errors.push(SyntaxError::new(MalformedUnicodeEscape, range));
-                    return;
-                }
-            }
-            if !closed {
+fn validate_unicode_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
-                errors.push(SyntaxError::new(UnclosedUnicodeEscape, range))
+    assert!(&text[..2] == "\\u", "UnicodeEscape always starts with \\u");
-            }
-            if code.len() == 0 {
+    if text.len() == 2 {
-                errors.push(SyntaxError::new(EmptyUnicodeEcape, range));
+        // No starting `{`
+        errors.push(SyntaxError::new(MalformedUnicodeEscape, range));
+        return;
+    }
+    if text.len() == 3 {
+        // Only starting `{`
+        errors.push(SyntaxError::new(UnclosedUnicodeEscape, range));
+        return;
+    }
+    let mut code = ArrayString::<[_; 6]>::new();
+    let mut closed = false;
+    for c in text[3..].chars() {
+        assert!(!closed, "no characters after escape is closed");
+        if c.is_digit(16) {
+            if code.len() == 6 {
+                errors.push(SyntaxError::new(OverlongUnicodeEscape, range));
                return;
            }
-            match u32::from_str_radix(&code, 16) {
+            code.push(c);
-                Ok(code_u32) if code_u32 > 0x10FFFF => {
+        } else if c == '_' {
-                    errors.push(SyntaxError::new(UnicodeEscapeOutOfRange, range));
+            // Reject leading _
-                }
+            if code.len() == 0 {
-                Ok(_) => {
+                errors.push(SyntaxError::new(MalformedUnicodeEscape, range));
-                    // Valid escape code
+                return;
-                }
-                Err(_) => {
-                    errors.push(SyntaxError::new(MalformedUnicodeEscape, range));
-                }
-            }
-        }
-        CodePoint => {
-            // These code points must always be escaped
-            if text == "\t" || text == "\r" {
-                errors.push(SyntaxError::new(UnescapedCodepoint, range));
            }
+        } else if c == '}' {
+            closed = true;
+        } else {
+            errors.push(SyntaxError::new(MalformedUnicodeEscape, range));
+            return;
        }
    }
-}
-fn is_ascii_escape(code: char) -> bool {
+    if !closed {
-    match code {
+        errors.push(SyntaxError::new(UnclosedUnicodeEscape, range))
-        '\\' | '\'' | '"' | 'n' | 'r' | 't' | '0' => true,
+    }
-        _ => false,
+    if code.len() == 0 {
+        errors.push(SyntaxError::new(EmptyUnicodeEcape, range));
+        return;
+    }
+    match u32::from_str_radix(&code, 16) {
+        Ok(code_u32) if code_u32 > 0x10FFFF => {
+            errors.push(SyntaxError::new(UnicodeEscapeOutOfRange, range));
+        }
+        Ok(_) => {
+            // Valid escape code
+        }
+        Err(_) => {
+            errors.push(SyntaxError::new(MalformedUnicodeEscape, range));
+        }
    }
 }
@@ -205,9 +213,7 @@ mod test {
    #[test]
    fn test_valid_ascii_escape() {
-        let valid = [
+        let valid = [r"\'", "\"", "\\\\", "\\\"", r"\n", r"\r", r"\t", r"\0"];
-            r"\'", "\"", "\\\\", "\\\"", r"\n", r"\r", r"\t", r"\0", "a", "b",
-        ];
        for c in &valid {
            assert_valid_char(c);
        }
diff --git a/crates/ra_syntax/src/validation/mod.rs b/crates/ra_syntax/src/validation/mod.rs
index 2ff0bc26d..bdee8120c 100644
--- a/crates/ra_syntax/src/validation/mod.rs
+++ b/crates/ra_syntax/src/validation/mod.rs
@@ -5,6 +5,8 @@ use crate::{
    yellow::SyntaxError,
 };
+mod byte;
+mod byte_string;
 mod char;
 mod string;
@@ -12,6 +14,8 @@ pub(crate) fn validate(file: &SourceFileNode) -> Vec<SyntaxError> {
    let mut errors = Vec::new();
    for node in file.syntax().descendants() {
        let _ = visitor_ctx(&mut errors)
+            .visit::<ast::Byte, _>(self::byte::validate_byte_node)
+            .visit::<ast::ByteString, _>(self::byte_string::validate_byte_string_node)
            .visit::<ast::Char, _>(self::char::validate_char_node)
            .visit::<ast::String, _>(self::string::validate_string_node)
            .accept(node);
diff --git a/crates/ra_syntax/src/yellow/syntax_error.rs b/crates/ra_syntax/src/yellow/syntax_error.rs
index cf7b1d495..c32ee650d 100644
--- a/crates/ra_syntax/src/yellow/syntax_error.rs
+++ b/crates/ra_syntax/src/yellow/syntax_error.rs
@@ -72,6 +72,16 @@ pub enum SyntaxErrorKind {
    EmptyChar,
    UnclosedChar,
    OverlongChar,
+    EmptyByte,
+    UnclosedByte,
+    OverlongByte,
+    ByteOutOfRange,
+    UnescapedByte,
+    EmptyByteEscape,
+    InvalidByteEscape,
+    TooShortByteCodeEscape,
+    MalformedByteCodeEscape,
+    UnicodeEscapeForbidden,
    EmptyAsciiEscape,
    InvalidAsciiEscape,
    TooShortAsciiCodeEscape,
@@ -98,6 +108,19 @@ impl fmt::Display for SyntaxErrorKind {
            EmptyChar => write!(f, "Empty char literal"),
            UnclosedChar => write!(f, "Unclosed char literal"),
            OverlongChar => write!(f, "Char literal should be one character long"),
+            EmptyByte => write!(f, "Empty byte literal"),
+            UnclosedByte => write!(f, "Unclosed byte literal"),
+            OverlongByte => write!(f, "Byte literal should be one character long"),
+            ByteOutOfRange => write!(f, "Byte should be a valid ASCII character"),
+            UnescapedByte => write!(f, "This byte should always be escaped"),
+            EmptyByteEscape => write!(f, "Empty escape sequence"),
+            InvalidByteEscape => write!(f, "Invalid escape sequence"),
+            TooShortByteCodeEscape => write!(f, "Escape sequence should have two digits"),
+            MalformedByteCodeEscape => write!(f, "Escape sequence should be a hexadecimal number"),
+            UnicodeEscapeForbidden => write!(
+                f,
+                "Unicode escapes are not allowed in byte literals or byte strings"
+            ),
            TooShortAsciiCodeEscape => write!(f, "Escape sequence should have two digits"),
            AsciiCodeEscapeOutOfRange => {
                write!(f, "Escape sequence should be between \\x00 and \\x7F")
diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs
index 8b8e9974e..3013f4e36 100644
--- a/crates/tools/src/lib.rs
+++ b/crates/tools/src/lib.rs
@@ -17,7 +17,7 @@ pub type Result<T> = ::std::result::Result<T, failure::Error>;
 pub const GRAMMAR: &str = "crates/ra_syntax/src/grammar.ron";
 pub const SYNTAX_KINDS: &str = "crates/ra_syntax/src/syntax_kinds/generated.rs.tera";
 pub const AST: &str = "crates/ra_syntax/src/ast/generated.rs.tera";
-const TOOLCHAIN: &str = "beta-2018-10-30";
+const TOOLCHAIN: &str = "beta-2018-11-24";
 #[derive(Debug)]
 pub struct Test {
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index fe304623f..530a6f77d 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -527,8 +527,7 @@
        "duplexer": {
            "version": "0.1.1",
            "resolved": "http://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
-            "integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=",
+            "integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E="
-            "dev": true
        },
        "duplexify": {
            "version": "3.6.0",
@@ -587,18 +586,16 @@
            "dev": true
        },
        "event-stream": {
-            "version": "3.3.6",
+            "version": "3.3.4",
-            "resolved": "https://registry.npmjs.org/event-stream/-/event-stream-3.3.6.tgz",
+            "resolved": "http://registry.npmjs.org/event-stream/-/event-stream-3.3.4.tgz",
-            "integrity": "sha512-dGXNg4F/FgVzlApjzItL+7naHutA3fDqbV/zAZqDDlXTjiMnQmZKu+prImWKszeBM5UQeGvAl3u1wBiKeDh61g==",
+            "integrity": "sha1-SrTJoPWlTbkzi0w02Gv86PSzVXE=",
-            "dev": true,
            "requires": {
                "duplexer": "0.1.1",
-                "flatmap-stream": "0.1.0",
                "from": "0.1.7",
-                "map-stream": "0.0.7",
+                "map-stream": "0.1.0",
                "pause-stream": "0.0.11",
-                "split": "1.0.1",
+                "split": "0.3.3",
-                "stream-combiner": "0.2.2",
+                "stream-combiner": "0.0.4",
                "through": "2.3.8"
            }
        },
@@ -704,12 +701,6 @@
            "integrity": "sha1-Wb+1DNkF9g18OUzT2ayqtOatk04=",
            "dev": true
        },
-        "flatmap-stream": {
-            "version": "0.1.0",
-            "resolved": "https://registry.npmjs.org/flatmap-stream/-/flatmap-stream-0.1.0.tgz",
-            "integrity": "sha512-Nlic4ZRYxikqnK5rj3YoxDVKGGtUjcNDUtvQ7XsdGLZmMwdUYnXf10o1zcXtzEZTBgc6GxeRpQxV/Wu3WPIIHA==",
-            "dev": true
-        },
        "for-in": {
            "version": "1.0.2",
            "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz",
@@ -745,8 +736,7 @@
        "from": {
            "version": "0.1.7",
            "resolved": "https://registry.npmjs.org/from/-/from-0.1.7.tgz",
-            "integrity": "sha1-g8YK/Fi5xWmXAH7Rp2izqzA6RP4=",
+            "integrity": "sha1-g8YK/Fi5xWmXAH7Rp2izqzA6RP4="
-            "dev": true
        },
        "fs.realpath": {
            "version": "1.0.0",
@@ -986,7 +976,7 @@
            "integrity": "sha512-/9vtSk9eI9DEWCqzGieglPqmx0WUQ9pwPHyHFpKmfxqdgqGJC2l0vFMdYs54hLdDsMDEZFLDL2J4ikjc4hQ5HQ==",
            "dev": true,
            "requires": {
-                "event-stream": "3.3.6",
+                "event-stream": "3.3.4",
                "node.extend": "1.1.6",
                "request": "2.88.0",
                "through2": "2.0.3",
@@ -1065,7 +1055,7 @@
            "integrity": "sha1-wWUyBzLRks5W/ZQnH/oSMjS/KuA=",
            "dev": true,
            "requires": {
-                "event-stream": "3.3.6",
+                "event-stream": "3.3.4",
                "mkdirp": "0.5.1",
                "queue": "3.1.0",
                "vinyl-fs": "2.4.4"
@@ -1077,7 +1067,7 @@
            "integrity": "sha512-0QfbCH2a1k2qkTLWPqTX+QO4qNsHn3kC546YhAP3/n0h+nvtyGITDuDrYBMDZeW4WnFijmkOvBWa5HshTic1tw==",
            "dev": true,
            "requires": {
-                "event-stream": "3.3.6",
+                "event-stream": "3.3.4",
                "streamifier": "0.1.1",
                "tar": "2.2.1",
                "through2": "2.0.3",
@@ -1115,7 +1105,7 @@
            "integrity": "sha1-JOQGhdwFtxSZlSRQmeBZAmO+ja0=",
            "dev": true,
            "requires": {
-                "event-stream": "3.3.6",
+                "event-stream": "3.3.4",
                "queue": "4.5.0",
                "through2": "2.0.3",
                "vinyl": "2.2.0",
@@ -1475,10 +1465,9 @@
            "dev": true
        },
        "map-stream": {
-            "version": "0.0.7",
+            "version": "0.1.0",
-            "resolved": "https://registry.npmjs.org/map-stream/-/map-stream-0.0.7.tgz",
+            "resolved": "http://registry.npmjs.org/map-stream/-/map-stream-0.1.0.tgz",
-            "integrity": "sha1-ih8HiW2CsQkmvTdEokIACfiJdKg=",
+            "integrity": "sha1-5WqpTEyAVaFkBKBnS3jyFffI4ZQ="
-            "dev": true
        },
        "markdown-it": {
            "version": "8.4.2",
@@ -1838,7 +1827,6 @@
            "version": "0.0.11",
            "resolved": "http://registry.npmjs.org/pause-stream/-/pause-stream-0.0.11.tgz",
            "integrity": "sha1-/lo0sMvOErWqaitAPuLnO2AvFEU=",
-            "dev": true,
            "requires": {
                "through": "2.3.8"
            }
@@ -2093,10 +2081,9 @@
            }
        },
        "split": {
-            "version": "1.0.1",
+            "version": "0.3.3",
-            "resolved": "https://registry.npmjs.org/split/-/split-1.0.1.tgz",
+            "resolved": "http://registry.npmjs.org/split/-/split-0.3.3.tgz",
-            "integrity": "sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==",
+            "integrity": "sha1-zQ7qXmOiEd//frDwkcQTPi0N0o8=",
-            "dev": true,
            "requires": {
                "through": "2.3.8"
            }
@@ -2131,13 +2118,11 @@
            "dev": true
        },
        "stream-combiner": {
-            "version": "0.2.2",
+            "version": "0.0.4",
-            "resolved": "http://registry.npmjs.org/stream-combiner/-/stream-combiner-0.2.2.tgz",
+            "resolved": "http://registry.npmjs.org/stream-combiner/-/stream-combiner-0.0.4.tgz",
-            "integrity": "sha1-rsjLrBd7Vrb0+kec7YwZEs7lKFg=",
+            "integrity": "sha1-TV5DPBhSYd3mI8o/RMWGvPXErRQ=",
-            "dev": true,
            "requires": {
-                "duplexer": "0.1.1",
+                "duplexer": "0.1.1"
-                "through": "2.3.8"
            }
        },
        "stream-shift": {
@@ -2221,8 +2206,7 @@
        "through": {
            "version": "2.3.8",
            "resolved": "http://registry.npmjs.org/through/-/through-2.3.8.tgz",
-            "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=",
+            "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU="
-            "dev": true
        },
        "through2": {
            "version": "2.0.3",
diff --git a/editors/code/package.json b/editors/code/package.json
index ea84a1ccb..f3b049e43 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -28,6 +28,7 @@
        "singleQuote": true
    },
    "dependencies": {
+        "event-stream": "^3.3.4",
        "vscode-languageclient": "^5.1.1"
    },
    "devDependencies": {