76 files changed, 1930 insertions, 1524 deletions
diff --git a/crates/gen_lsp_server/src/lib.rs b/crates/gen_lsp_server/src/lib.rs
index 645728a57..e45a6b5e2 100644
--- a/crates/gen_lsp_server/src/lib.rs
+++ b/crates/gen_lsp_server/src/lib.rs
@@ -59,7 +59,6 @@
 //! }
 //! ```
 #[macro_use]
 extern crate failure;
 #[macro_use]
@@ -74,16 +73,16 @@ extern crate languageserver_types;
 mod msg;
 mod stdio;
-use crossbeam_channel::{Sender, Receiver};
+use crossbeam_channel::{Receiver, Sender};
 use languageserver_types::{
-    ServerCapabilities, InitializeResult, InitializeParams,
+    notification::{Exit, Initialized},
    request::{Initialize, Shutdown},
-    notification::{Initialized, Exit},
+    InitializeParams, InitializeResult, ServerCapabilities,
 };
 pub type Result<T> = ::std::result::Result<T, failure::Error>;
 pub use {
-    msg::{RawMessage, RawRequest, RawResponse, RawResponseError, RawNotification, ErrorCode},
+    msg::{ErrorCode, RawMessage, RawNotification, RawRequest, RawResponse, RawResponseError},
    stdio::{stdio_transport, Threads},
 };
@@ -97,11 +96,7 @@ pub fn run_server(
    caps: ServerCapabilities,
    receiver: Receiver<RawMessage>,
    sender: Sender<RawMessage>,
-    server: impl FnOnce(
+    server: impl FnOnce(InitializeParams, &Receiver<RawMessage>, &Sender<RawMessage>) -> Result<()>,
-        InitializeParams,
-        &Receiver<RawMessage>,
-        &Sender<RawMessage>,
-    ) -> Result<()>,
 ) -> Result<()> {
    info!("lsp server initializes");
    let params = initialize(&receiver, &sender, caps)?;
@@ -109,12 +104,10 @@ pub fn run_server(
    server(params, &receiver, &sender)?;
    info!("lsp server waiting for exit notification");
    match receiver.recv() {
-        Some(RawMessage::Notification(n)) => {
+        Some(RawMessage::Notification(n)) => n
-            n.cast::<Exit>().map_err(|n| format_err!(
+            .cast::<Exit>()
-                "unexpected notification during shutdown: {:?}", n
+            .map_err(|n| format_err!("unexpected notification during shutdown: {:?}", n))?,
-            ))?
+        m => bail!("unexpected message during shutdown: {:?}", m),
-        }
-        m => bail!("unexpected message during shutdown: {:?}", m)
    }
    info!("lsp server shutdown complete");
    Ok(())
@@ -141,17 +134,15 @@ fn initialize(
        Some(RawMessage::Request(req)) => match req.cast::<Initialize>() {
            Err(req) => bail!("expected initialize request, got {:?}", req),
            Ok(req) => req,
-        }
+        },
-        msg =>
+        msg => bail!("expected initialize request, got {:?}", msg),
-            bail!("expected initialize request, got {:?}", msg),
    };
    let resp = RawResponse::ok::<Initialize>(id, &InitializeResult { capabilities: caps });
    sender.send(RawMessage::Response(resp));
    match receiver.recv() {
        Some(RawMessage::Notification(n)) => {
-            n.cast::<Initialized>().map_err(|_| format_err!(
+            n.cast::<Initialized>()
-                "expected initialized notification"
+                .map_err(|_| format_err!("expected initialized notification"))?;
-            ))?;
        }
        _ => bail!("expected initialized notification"),
    }
diff --git a/crates/gen_lsp_server/src/msg.rs b/crates/gen_lsp_server/src/msg.rs
index 7fcac6f6d..e0d0aeab5 100644
--- a/crates/gen_lsp_server/src/msg.rs
+++ b/crates/gen_lsp_server/src/msg.rs
@@ -1,11 +1,8 @@
 use std::io::{BufRead, Write};
-use serde_json::{Value, from_str, to_string, from_value, to_value};
+use languageserver_types::{notification::Notification, request::Request};
-use serde::{Serialize, de::DeserializeOwned};
+use serde::{de::DeserializeOwned, Serialize};
-use languageserver_types::{
+use serde_json::{from_str, from_value, to_string, to_value, Value};
-    request::Request,
-    notification::Notification,
-};
 use Result;
@@ -81,7 +78,10 @@ impl RawMessage {
            #[serde(flatten)]
            msg: RawMessage,
        }
-        let text = to_string(&JsonRpc { jsonrpc: "2.0", msg: self })?;
+        let text = to_string(&JsonRpc {
+            jsonrpc: "2.0",
+            msg: self,
+        })?;
        write_msg_text(w, &text)?;
        Ok(())
    }
@@ -115,8 +115,9 @@ impl RawRequest {
 impl RawResponse {
    pub fn ok<R>(id: u64, result: &R::Result) -> RawResponse
-    where R: Request,
+    where
-          R::Result: Serialize,
+        R: Request,
+        R::Result: Serialize,
    {
        RawResponse {
            id,
@@ -125,7 +126,11 @@ impl RawResponse {
        }
    }
    pub fn err(id: u64, code: i32, message: String) -> RawResponse {
-        let error = RawResponseError { code, message, data: None };
+        let error = RawResponseError {
+            code,
+            message,
+            data: None,
+        };
        RawResponse {
            id,
            result: None,
@@ -174,7 +179,9 @@ fn read_msg_text(inp: &mut impl BufRead) -> Result<Option<String>> {
        }
        let mut parts = buf.splitn(2, ": ");
        let header_name = parts.next().unwrap();
-        let header_value = parts.next().ok_or_else(|| format_err!("malformed header: {:?}", buf))?;
+        let header_value = parts
+            .next()
+            .ok_or_else(|| format_err!("malformed header: {:?}", buf))?;
        if header_name == "Content-Length" {
            size = Some(header_value.parse::<usize>()?);
        }
diff --git a/crates/gen_lsp_server/src/stdio.rs b/crates/gen_lsp_server/src/stdio.rs
index 81397bb2a..3d8a1712a 100644
--- a/crates/gen_lsp_server/src/stdio.rs
+++ b/crates/gen_lsp_server/src/stdio.rs
@@ -1,11 +1,9 @@
 use std::{
+    io::{stdin, stdout},
    thread,
-    io::{
-        stdout, stdin,
-    },
 };
-use crossbeam_channel::{Receiver, Sender, bounded};
+use crossbeam_channel::{bounded, Receiver, Sender};
 use {RawMessage, Result};
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index c69577233..042dde1ac 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,17 +1,18 @@
-use std::{
-    fmt,
-    sync::Arc,
-    hash::{Hash, Hasher},
-};
-use salsa;
-use rustc_hash::FxHashSet;
-use ra_syntax::File;
-use ra_editor::{LineIndex};
 use crate::{
+    module_map::{ModuleDescriptorQuery, ModuleTreeQuery, ModulesDatabase},
    symbol_index::SymbolIndex,
-    module_map::{ModulesDatabase, ModuleTreeQuery, ModuleDescriptorQuery},
    FileId, FileResolverImp,
 };
+use ra_editor::LineIndex;
+use ra_syntax::File;
+use rustc_hash::FxHashSet;
+use salsa;
+use std::{
+    fmt,
+    hash::{Hash, Hasher},
+    sync::Arc,
+};
 #[derive(Default)]
 pub(crate) struct RootDatabase {
diff --git a/crates/ra_analysis/src/descriptors.rs b/crates/ra_analysis/src/descriptors.rs
index 8d9f38ca5..6f26f9935 100644
--- a/crates/ra_analysis/src/descriptors.rs
+++ b/crates/ra_analysis/src/descriptors.rs
@@ -1,41 +1,34 @@
-use std::{
+use crate::{imp::FileResolverImp, FileId};
-    collections::BTreeMap,
-};
-use relative_path::RelativePathBuf;
 use ra_syntax::{
+    ast::{self, AstNode, NameOwner},
+    text_utils::is_subrange,
    SmolStr,
-    ast::{self, NameOwner, AstNode},
-    text_utils::is_subrange
-};
-use crate::{
-    FileId,
-    imp::FileResolverImp,
 };
+use relative_path::RelativePathBuf;
+use std::collections::BTreeMap;
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct ModuleDescriptor {
-    pub submodules: Vec<Submodule>
+    pub submodules: Vec<Submodule>,
 }
 impl ModuleDescriptor {
    pub fn new(root: ast::Root) -> ModuleDescriptor {
-        let submodules = modules(root)
+        let submodules = modules(root).map(|(name, _)| Submodule { name }).collect();
-            .map(|(name, _)| Submodule { name })
-            .collect();
-        ModuleDescriptor { submodules } }
+        ModuleDescriptor { submodules }
+    }
 }
-fn modules<'a>(root: ast::Root<'a>) -> impl Iterator<Item=(SmolStr, ast::Module<'a>)> {
+fn modules<'a>(root: ast::Root<'a>) -> impl Iterator<Item = (SmolStr, ast::Module<'a>)> {
-    root
+    root.modules().filter_map(|module| {
-        .modules()
+        let name = module.name()?.text();
-        .filter_map(|module| {
+        if !module.has_semi() {
-            let name = module.name()?.text();
+            return None;
-            if !module.has_semi() {
+        }
-                return None;
+        Some((name, module))
-            }
+    })
-            Some((name, module))
-        })
 }
 #[derive(Clone, Hash, PartialEq, Eq, Debug)]
@@ -56,7 +49,7 @@ struct Node(usize);
 struct NodeData {
    file_id: FileId,
    links: Vec<Link>,
-    parents: Vec<Link>
+    parents: Vec<Link>,
 }
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
@@ -69,7 +62,6 @@ struct LinkData {
    problem: Option<Problem>,
 }
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum Problem {
    UnresolvedModule {
@@ -78,16 +70,18 @@ pub enum Problem {
    NotDirOwner {
        move_to: RelativePathBuf,
        candidate: RelativePathBuf,
-    }
+    },
 }
 impl ModuleTreeDescriptor {
    pub(crate) fn new<'a>(
-        files: impl Iterator<Item=(FileId, &'a ModuleDescriptor)> + Clone,
+        files: impl Iterator<Item = (FileId, &'a ModuleDescriptor)> + Clone,
        file_resolver: &FileResolverImp,
    ) -> ModuleTreeDescriptor {
        let mut file_id2node = BTreeMap::new();
-        let mut nodes: Vec<NodeData> = files.clone().enumerate()
+        let mut nodes: Vec<NodeData> = files
+            .clone()
+            .enumerate()
            .map(|(idx, (file_id, _))| {
                file_id2node.insert(file_id, Node(idx));
                NodeData {
@@ -120,20 +114,19 @@ impl ModuleTreeDescriptor {
                    points_to,
                    problem,
                })
            }
        }
        ModuleTreeDescriptor {
-            nodes, links, file_id2node
+            nodes,
+            links,
+            file_id2node,
        }
    }
    pub(crate) fn parent_modules(&self, file_id: FileId) -> Vec<Link> {
        let node = self.file_id2node[&file_id];
-        self.node(node)
+        self.node(node).parents.clone()
-            .parents
-            .clone()
    }
    pub(crate) fn child_module_by_name(&self, file_id: FileId, name: &str) -> Vec<FileId> {
        let node = self.file_id2node[&file_id];
@@ -141,10 +134,18 @@ impl ModuleTreeDescriptor {
            .links
            .iter()
            .filter(|it| it.name(self) == name)
-            .flat_map(|link| link.points_to(self).iter().map(|&node| self.node(node).file_id))
+            .flat_map(|link| {
+                link.points_to(self)
+                    .iter()
+                    .map(|&node| self.node(node).file_id)
+            })
            .collect()
    }
-    pub(crate) fn problems<'a, 'b>(&'b self, file_id: FileId, root: ast::Root<'a>) -> Vec<(ast::Name<'a>, &'b Problem)> {
+    pub(crate) fn problems<'a, 'b>(
+        &'b self,
+        file_id: FileId,
+        root: ast::Root<'a>,
+    ) -> Vec<(ast::Name<'a>, &'b Problem)> {
        let node = self.file_id2node[&file_id];
        self.node(node)
            .links
@@ -176,7 +177,11 @@ impl Link {
    fn points_to(self, tree: &ModuleTreeDescriptor) -> &[Node] {
        &tree.link(self).points_to
    }
-    pub(crate) fn bind_source<'a>(self, tree: &ModuleTreeDescriptor, root: ast::Root<'a>) -> ast::Module<'a> {
+    pub(crate) fn bind_source<'a>(
+        self,
+        tree: &ModuleTreeDescriptor,
+        root: ast::Root<'a>,
+    ) -> ast::Module<'a> {
        modules(root)
            .filter(|(name, _)| name == &tree.link(self).name)
            .next()
@@ -185,22 +190,21 @@ impl Link {
    }
 }
 fn resolve_submodule(
    file_id: FileId,
    name: &SmolStr,
-    file_resolver: &FileResolverImp
+    file_resolver: &FileResolverImp,
 ) -> (Vec<FileId>, Option<Problem>) {
    let mod_name = file_resolver.file_stem(file_id);
-    let is_dir_owner =
+    let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main";
-        mod_name == "mod" || mod_name == "lib" || mod_name == "main";
    let file_mod = RelativePathBuf::from(format!("../{}.rs", name));
    let dir_mod = RelativePathBuf::from(format!("../{}/mod.rs", name));
    let points_to: Vec<FileId>;
    let problem: Option<Problem>;
    if is_dir_owner {
-        points_to = [&file_mod, &dir_mod].iter()
+        points_to = [&file_mod, &dir_mod]
+            .iter()
            .filter_map(|path| file_resolver.resolve(file_id, path))
            .collect();
        problem = if points_to.is_empty() {
@@ -223,7 +227,7 @@ fn resolve_submodule(
 #[derive(Debug, Clone)]
 pub struct FnDescriptor {
    pub name: String,
-    pub label : String,
+    pub label: String,
    pub ret_type: Option<String>,
    pub params: Vec<String>,
 }
@@ -233,9 +237,11 @@ impl FnDescriptor {
        let name = node.name()?.text().to_string();
        // Strip the body out for the label.
-        let label : String = if let Some(body) = node.body() {
+        let label: String = if let Some(body) = node.body() {
            let body_range = body.syntax().range();
-            let label : String = node.syntax().children()
+            let label: String = node
+                .syntax()
+                .children()
                .filter(|child| !is_subrange(body_range, child.range()))
                .map(|node| node.text().to_string())
                .collect();
@@ -251,7 +257,7 @@ impl FnDescriptor {
            name,
            ret_type,
            params,
-            label
+            label,
        })
    }
@@ -264,9 +270,11 @@ impl FnDescriptor {
            // Maybe use param.pat here? See if we can just extract the name?
            //res.extend(param_list.params().map(|p| p.syntax().text().to_string()));
-            res.extend(param_list.params()
+            res.extend(
-                .filter_map(|p| p.pat())
+                param_list
-                .map(|pat| pat.syntax().text().to_string())
+                    .params()
+                    .filter_map(|p| p.pat())
+                    .map(|pat| pat.syntax().text().to_string()),
            );
        }
        res
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 5efcaeca0..f1403cb5d 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -1,32 +1,31 @@
 use std::{
-    sync::{
-        Arc,
-    },
-    hash::{Hash, Hasher},
-    fmt,
    collections::VecDeque,
+    fmt,
+    hash::{Hash, Hasher},
    iter,
+    sync::Arc,
 };
-use relative_path::RelativePath;
+use ra_editor::{self, find_node_at_offset, resolve_local_name, FileSymbol, LineIndex, LocalEdit};
-use rustc_hash::FxHashSet;
-use ra_editor::{self, FileSymbol, LineIndex, find_node_at_offset, LocalEdit, resolve_local_name};
 use ra_syntax::{
-    TextUnit, TextRange, SmolStr, File, AstNode, SyntaxNodeRef,
+    ast::{self, ArgListOwner, Expr, NameOwner},
+    AstNode, File, SmolStr,
    SyntaxKind::*,
-    ast::{self, NameOwner, ArgListOwner, Expr},
+    SyntaxNodeRef, TextRange, TextUnit,
 };
+use relative_path::RelativePath;
+use rustc_hash::FxHashSet;
 use crate::{
-    FileId, FileResolver, Query, Diagnostic, SourceChange, SourceFileEdit, Position, FileSystemEdit,
-    JobToken, CrateGraph, CrateId,
-    roots::{SourceRoot, ReadonlySourceRoot, WritableSourceRoot},
    descriptors::{FnDescriptor, ModuleTreeDescriptor, Problem},
+    roots::{ReadonlySourceRoot, SourceRoot, WritableSourceRoot},
+    CrateGraph, CrateId, Diagnostic, FileId, FileResolver, FileSystemEdit, JobToken, Position,
+    Query, SourceChange, SourceFileEdit,
 };
 #[derive(Clone, Debug)]
 pub(crate) struct FileResolverImp {
-    inner: Arc<FileResolver>
+    inner: Arc<FileResolver>,
 }
 impl PartialEq for FileResolverImp {
@@ -35,8 +34,7 @@ impl PartialEq for FileResolverImp {
    }
 }
-impl Eq for FileResolverImp {
+impl Eq for FileResolverImp {}
-}
 impl Hash for FileResolverImp {
    fn hash<H: Hasher>(&self, hasher: &mut H) {
@@ -67,17 +65,23 @@ impl Default for FileResolverImp {
            fn file_stem(&self, _file_: FileId) -> String {
                panic!("file resolver not set")
            }
-            fn resolve(&self, _file_id: FileId, _path: &::relative_path::RelativePath) -> Option<FileId> {
+            fn resolve(
+                &self,
+                _file_id: FileId,
+                _path: &::relative_path::RelativePath,
+            ) -> Option<FileId> {
                panic!("file resolver not set")
            }
        }
-        FileResolverImp { inner: Arc::new(DummyResolver) }
+        FileResolverImp {
+            inner: Arc::new(DummyResolver),
+        }
    }
 }
 #[derive(Debug)]
 pub(crate) struct AnalysisHostImpl {
-    data: WorldData
+    data: WorldData,
 }
 impl AnalysisHostImpl {
@@ -91,13 +95,13 @@ impl AnalysisHostImpl {
            data: self.data.clone(),
        }
    }
-    pub fn change_files(&mut self, changes: &mut dyn Iterator<Item=(FileId, Option<String>)>) {
+    pub fn change_files(&mut self, changes: &mut dyn Iterator<Item = (FileId, Option<String>)>) {
-        self.data_mut()
+        self.data_mut().root.apply_changes(changes, None);
-            .root.apply_changes(changes, None);
    }
    pub fn set_file_resolver(&mut self, resolver: FileResolverImp) {
        self.data_mut()
-            .root.apply_changes(&mut iter::empty(), Some(resolver));
+            .root
+            .apply_changes(&mut iter::empty(), Some(resolver));
    }
    pub fn set_crate_graph(&mut self, graph: CrateGraph) {
        let mut visited = FxHashSet::default();
@@ -131,7 +135,12 @@ impl AnalysisImpl {
        if self.data.root.contains(file_id) {
            return &self.data.root;
        }
-        &**self.data.libs.iter().find(|it| it.contains(file_id)).unwrap()
+        &**self
+            .data
+            .libs
+            .iter()
+            .find(|it| it.contains(file_id))
+            .unwrap()
    }
    pub fn file_syntax(&self, file_id: FileId) -> File {
        self.root(file_id).syntax(file_id)
@@ -142,18 +151,17 @@ impl AnalysisImpl {
    pub fn world_symbols(&self, query: Query, token: &JobToken) -> Vec<(FileId, FileSymbol)> {
        let mut buf = Vec::new();
        if query.libs {
-            self.data.libs.iter()
+            self.data.libs.iter().for_each(|it| it.symbols(&mut buf));
-                .for_each(|it| it.symbols(&mut buf));
        } else {
            self.data.root.symbols(&mut buf);
        }
        query.search(&buf, token)
    }
    pub fn parent_module(&self, file_id: FileId) -> Vec<(FileId, FileSymbol)> {
        let root = self.root(file_id);
        let module_tree = root.module_tree();
-        module_tree.parent_modules(file_id)
+        module_tree
+            .parent_modules(file_id)
            .iter()
            .map(|link| {
                let file_id = link.owner(&module_tree);
@@ -203,15 +211,17 @@ impl AnalysisImpl {
        let file = root.syntax(file_id);
        let syntax = file.syntax();
        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, offset) {
            // First try to resolve the symbol locally
            if let Some((name, range)) = resolve_local_name(&file, offset, name_ref) {
                let mut vec = vec![];
-                vec.push((file_id, FileSymbol {
+                vec.push((
-                    name,
+                    file_id,
-                    node_range: range,
+                    FileSymbol {
-                    kind : NAME
+                        name,
-                }));
+                        node_range: range,
+                        kind: NAME,
+                    },
+                ));
                return vec;
            } else {
@@ -224,17 +234,21 @@ impl AnalysisImpl {
                if module.has_semi() {
                    let file_ids = self.resolve_module(&*module_tree, file_id, module);
-                    let res = file_ids.into_iter().map(|id| {
+                    let res = file_ids
-                        let name = module.name()
+                        .into_iter()
-                            .map(|n| n.text())
+                        .map(|id| {
-                            .unwrap_or_else(|| SmolStr::new(""));
+                            let name = module
-                        let symbol = FileSymbol {
+                                .name()
-                            name,
+                                .map(|n| n.text())
-                            node_range: TextRange::offset_len(0.into(), 0.into()),
+                                .unwrap_or_else(|| SmolStr::new(""));
-                            kind: MODULE,
+                            let symbol = FileSymbol {
-                        };
+                                name,
-                        (id, symbol)
+                                node_range: TextRange::offset_len(0.into(), 0.into()),
-                    }).collect();
+                                kind: MODULE,
+                            };
+                            (id, symbol)
+                        })
+                        .collect();
                    return res;
                }
@@ -245,12 +259,16 @@ impl AnalysisImpl {
    pub fn diagnostics(&self, file_id: FileId) -> Vec<Diagnostic> {
        let root = self.root(file_id);
-        let module_tree  = root.module_tree();
+        let module_tree = root.module_tree();
        let syntax = root.syntax(file_id);
        let mut res = ra_editor::diagnostics(&syntax)
            .into_iter()
-            .map(|d| Diagnostic { range: d.range, message: d.msg, fix: None })
+            .map(|d| Diagnostic {
+                range: d.range,
+                message: d.msg,
+                fix: None,
+            })
            .collect::<Vec<_>>();
        for (name_node, problem) in module_tree.problems(file_id, syntax.ast()) {
@@ -273,8 +291,14 @@ impl AnalysisImpl {
                    }
                }
                Problem::NotDirOwner { move_to, candidate } => {
-                    let move_file = FileSystemEdit::MoveFile { file: file_id, path: move_to.clone() };
+                    let move_file = FileSystemEdit::MoveFile {
-                    let create_file = FileSystemEdit::CreateFile { anchor: file_id, path: move_to.join(candidate) };
+                        file: file_id,
+                        path: move_to.clone(),
+                    };
+                    let create_file = FileSystemEdit::CreateFile {
+                        anchor: file_id,
+                        path: move_to.join(candidate),
+                    };
                    let fix = SourceChange {
                        label: "move file and create module".to_string(),
                        source_file_edits: Vec::new(),
@@ -297,23 +321,34 @@ impl AnalysisImpl {
        let file = self.file_syntax(file_id);
        let offset = range.start();
        let actions = vec![
-            ("flip comma", ra_editor::flip_comma(&file, offset).map(|f| f())),
+            (
-            ("add `#[derive]`", ra_editor::add_derive(&file, offset).map(|f| f())),
+                "flip comma",
+                ra_editor::flip_comma(&file, offset).map(|f| f()),
+            ),
+            (
+                "add `#[derive]`",
+                ra_editor::add_derive(&file, offset).map(|f| f()),
+            ),
            ("add impl", ra_editor::add_impl(&file, offset).map(|f| f())),
-            ("introduce variable", ra_editor::introduce_variable(&file, range).map(|f| f())),
+            (
+                "introduce variable",
+                ra_editor::introduce_variable(&file, range).map(|f| f()),
+            ),
        ];
-        actions.into_iter()
+        actions
+            .into_iter()
            .filter_map(|(name, local_edit)| {
-                Some(SourceChange::from_local_edit(
+                Some(SourceChange::from_local_edit(file_id, name, local_edit?))
-                    file_id, name, local_edit?,
-                ))
            })
            .collect()
    }
-    pub fn resolve_callable(&self, file_id: FileId, offset: TextUnit, token: &JobToken)
+    pub fn resolve_callable(
-        -> Option<(FnDescriptor, Option<usize>)> {
+        &self,
+        file_id: FileId,
+        offset: TextUnit,
+        token: &JobToken,
+    ) -> Option<(FnDescriptor, Option<usize>)> {
        let root = self.root(file_id);
        let file = root.syntax(file_id);
        let syntax = file.syntax();
@@ -332,9 +367,7 @@ impl AnalysisImpl {
                        let mut current_parameter = None;
                        let num_params = descriptor.params.len();
-                        let has_self = fn_def.param_list()
+                        let has_self = fn_def.param_list().and_then(|l| l.self_param()).is_some();
-                            .and_then(|l| l.self_param())
-                            .is_some();
                        if num_params == 1 {
                            if !has_self {
@@ -350,8 +383,11 @@ impl AnalysisImpl {
                                let start = arg_list.syntax().range().start();
                                let range_search = TextRange::from_to(start, offset);
-                                let mut commas: usize = arg_list.syntax().text()
+                                let mut commas: usize = arg_list
-                                    .slice(range_search).to_string()
+                                    .syntax()
+                                    .text()
+                                    .slice(range_search)
+                                    .to_string()
                                    .matches(",")
                                    .count();
@@ -381,7 +417,12 @@ impl AnalysisImpl {
        self.world_symbols(query, token)
    }
-    fn resolve_module(&self, module_tree: &ModuleTreeDescriptor, file_id: FileId, module: ast::Module) -> Vec<FileId> {
+    fn resolve_module(
+        &self,
+        module_tree: &ModuleTreeDescriptor,
+        file_id: FileId,
+        module: ast::Module,
+    ) -> Vec<FileId> {
        let name = match module.name() {
            Some(name) => name.text(),
            None => return Vec::new(),
@@ -407,15 +448,17 @@ impl SourceChange {
            label: label.to_string(),
            source_file_edits: vec![file_edit],
            file_system_edits: vec![],
-            cursor_position: edit.cursor_position
+            cursor_position: edit
-                .map(|offset| Position { offset, file_id })
+                .cursor_position
+                .map(|offset| Position { offset, file_id }),
        }
    }
 }
 impl CrateGraph {
    fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
-        let (&crate_id, _) = self.crate_roots
+        let (&crate_id, _) = self
+            .crate_roots
            .iter()
            .find(|(_crate_id, &root_id)| root_id == file_id)?;
        Some(crate_id)
@@ -424,7 +467,7 @@ impl CrateGraph {
 enum FnCallNode<'a> {
    CallExpr(ast::CallExpr<'a>),
-    MethodCallExpr(ast::MethodCallExpr<'a>)
+    MethodCallExpr(ast::MethodCallExpr<'a>),
 }
 impl<'a> FnCallNode<'a> {
@@ -440,27 +483,23 @@ impl<'a> FnCallNode<'a> {
    pub fn name_ref(&self) -> Option<ast::NameRef> {
        match *self {
-            FnCallNode::CallExpr(call_expr) => {
+            FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()? {
-                Some(match call_expr.expr()? {
+                Expr::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?,
-                    Expr::PathExpr(path_expr) => {
+                _ => return None,
-                        path_expr.path()?.segment()?.name_ref()?
+            }),
-                    },
-                    _ => return None
+            FnCallNode::MethodCallExpr(call_expr) => call_expr
-                })
+                .syntax()
-            },
+                .children()
+                .filter_map(ast::NameRef::cast)
-            FnCallNode::MethodCallExpr(call_expr) => {
+                .nth(0),
-                call_expr.syntax().children()
-                    .filter_map(ast::NameRef::cast)
-                    .nth(0)
-            }
        }
    }
    pub fn arg_list(&self) -> Option<ast::ArgList> {
        match *self {
            FnCallNode::CallExpr(expr) => expr.arg_list(),
-            FnCallNode::MethodCallExpr(expr) => expr.arg_list()
+            FnCallNode::MethodCallExpr(expr) => expr.arg_list(),
        }
    }
 }
diff --git a/crates/ra_analysis/src/job.rs b/crates/ra_analysis/src/job.rs
index ea1652a26..2871f9839 100644
--- a/crates/ra_analysis/src/job.rs
+++ b/crates/ra_analysis/src/job.rs
@@ -14,15 +14,20 @@ impl JobHandle {
    pub fn new() -> (JobHandle, JobToken) {
        let (sender_alive, receiver_alive) = bounded(0);
        let (sender_canceled, receiver_canceled) = bounded(0);
-        let token = JobToken { _job_alive: sender_alive, job_canceled: receiver_canceled };
+        let token = JobToken {
-        let handle = JobHandle { job_alive: receiver_alive, _job_canceled: sender_canceled };
+            _job_alive: sender_alive,
+            job_canceled: receiver_canceled,
+        };
+        let handle = JobHandle {
+            job_alive: receiver_alive,
+            _job_canceled: sender_canceled,
+        };
        (handle, token)
    }
    pub fn has_completed(&self) -> bool {
        is_closed(&self.job_alive)
    }
-    pub fn cancel(self) {
+    pub fn cancel(self) {}
-    }
 }
 impl JobToken {
@@ -31,7 +36,6 @@ impl JobToken {
    }
 }
 // We don't actually send messages through the channels,
 // and instead just check if the channel is closed,
 // so we use uninhabited enum as a message type
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index d8b355a81..2eeacaabe 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -1,44 +1,40 @@
 extern crate parking_lot;
 #[macro_use]
 extern crate log;
+extern crate fst;
 extern crate once_cell;
-extern crate ra_syntax;
 extern crate ra_editor;
-extern crate fst;
+extern crate ra_syntax;
 extern crate rayon;
 extern crate relative_path;
 #[macro_use]
 extern crate crossbeam_channel;
 extern crate im;
-extern crate salsa;
 extern crate rustc_hash;
+extern crate salsa;
-mod symbol_index;
+mod db;
-mod module_map;
+mod descriptors;
 mod imp;
 mod job;
+mod module_map;
 mod roots;
-mod db;
+mod symbol_index;
-mod descriptors;
-use std::{
+use std::{fmt::Debug, sync::Arc};
-    sync::Arc,
-    fmt::Debug,
-};
+use crate::imp::{AnalysisHostImpl, AnalysisImpl, FileResolverImp};
+use ra_syntax::{AtomEdit, File, TextRange, TextUnit};
 use relative_path::{RelativePath, RelativePathBuf};
-use ra_syntax::{File, TextRange, TextUnit, AtomEdit};
 use rustc_hash::FxHashMap;
-use crate::imp::{AnalysisImpl, AnalysisHostImpl, FileResolverImp};
-pub use ra_editor::{
-    StructureNode, LineIndex, FileSymbol,
-    Runnable, RunnableKind, HighlightedRange, CompletionItem,
-    Fold, FoldKind
-};
 pub use crate::{
-    job::{JobToken, JobHandle},
    descriptors::FnDescriptor,
+    job::{JobHandle, JobToken},
+};
+pub use ra_editor::{
+    CompletionItem, FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable,
+    RunnableKind, StructureNode,
 };
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -59,20 +55,24 @@ pub trait FileResolver: Debug + Send + Sync + 'static {
 #[derive(Debug)]
 pub struct AnalysisHost {
-    imp: AnalysisHostImpl
+    imp: AnalysisHostImpl,
 }
 impl AnalysisHost {
    pub fn new() -> AnalysisHost {
-        AnalysisHost { imp: AnalysisHostImpl::new() }
+        AnalysisHost {
+            imp: AnalysisHostImpl::new(),
+        }
    }
    pub fn analysis(&self) -> Analysis {
-        Analysis { imp: self.imp.analysis() }
+        Analysis {
+            imp: self.imp.analysis(),
+        }
    }
    pub fn change_file(&mut self, file_id: FileId, text: Option<String>) {
        self.change_files(::std::iter::once((file_id, text)));
    }
-    pub fn change_files(&mut self, mut changes: impl Iterator<Item=(FileId, Option<String>)>) {
+    pub fn change_files(&mut self, mut changes: impl Iterator<Item = (FileId, Option<String>)>) {
        self.imp.change_files(&mut changes)
    }
    pub fn set_file_resolver(&mut self, resolver: Arc<FileResolver>) {
@@ -115,7 +115,7 @@ pub enum FileSystemEdit {
    MoveFile {
        file: FileId,
        path: RelativePathBuf,
-    }
+    },
 }
 #[derive(Debug)]
@@ -144,7 +144,7 @@ impl Query {
            only_types: false,
            libs: false,
            exact: false,
-            limit: usize::max_value()
+            limit: usize::max_value(),
        }
    }
    pub fn only_types(&mut self) {
@@ -163,7 +163,7 @@ impl Query {
 #[derive(Debug)]
 pub struct Analysis {
-    imp: AnalysisImpl
+    imp: AnalysisImpl,
 }
 impl Analysis {
@@ -195,7 +195,11 @@ impl Analysis {
    }
    pub fn on_eq_typed(&self, file_id: FileId, offset: TextUnit) -> Option<SourceChange> {
        let file = self.imp.file_syntax(file_id);
-        Some(SourceChange::from_local_edit(file_id, "add semicolon", ra_editor::on_eq_typed(&file, offset)?))
+        Some(SourceChange::from_local_edit(
+            file_id,
+            "add semicolon",
+            ra_editor::on_eq_typed(&file, offset)?,
+        ))
    }
    pub fn file_structure(&self, file_id: FileId) -> Vec<StructureNode> {
        let file = self.imp.file_syntax(file_id);
@@ -204,8 +208,14 @@ impl Analysis {
    pub fn symbol_search(&self, query: Query, token: &JobToken) -> Vec<(FileId, FileSymbol)> {
        self.imp.world_symbols(query, token)
    }
-    pub fn approximately_resolve_symbol(&self, file_id: FileId, offset: TextUnit, token: &JobToken) -> Vec<(FileId, FileSymbol)> {
+    pub fn approximately_resolve_symbol(
-        self.imp.approximately_resolve_symbol(file_id, offset, token)
+        &self,
+        file_id: FileId,
+        offset: TextUnit,
+        token: &JobToken,
+    ) -> Vec<(FileId, FileSymbol)> {
+        self.imp
+            .approximately_resolve_symbol(file_id, offset, token)
    }
    pub fn parent_module(&self, file_id: FileId) -> Vec<(FileId, FileSymbol)> {
        self.imp.parent_module(file_id)
@@ -239,15 +249,19 @@ impl Analysis {
        ra_editor::folding_ranges(&file)
    }
-    pub fn resolve_callable(&self, file_id: FileId, offset: TextUnit, token: &JobToken)
+    pub fn resolve_callable(
-        -> Option<(FnDescriptor, Option<usize>)> {
+        &self,
+        file_id: FileId,
+        offset: TextUnit,
+        token: &JobToken,
+    ) -> Option<(FnDescriptor, Option<usize>)> {
        self.imp.resolve_callable(file_id, offset, token)
    }
 }
 #[derive(Debug)]
 pub struct LibraryData {
-    root: roots::ReadonlySourceRoot
+    root: roots::ReadonlySourceRoot,
 }
 impl LibraryData {
diff --git a/crates/ra_analysis/src/module_map.rs b/crates/ra_analysis/src/module_map.rs
index c1799e3d4..ff0ec3cc7 100644
--- a/crates/ra_analysis/src/module_map.rs
+++ b/crates/ra_analysis/src/module_map.rs
@@ -1,10 +1,11 @@
-use std::sync::Arc;
 use crate::{
-    FileId,
+    db::SyntaxDatabase,
-    db::{SyntaxDatabase},
    descriptors::{ModuleDescriptor, ModuleTreeDescriptor},
+    FileId,
 };
+use std::sync::Arc;
 salsa::query_group! {
    pub(crate) trait ModulesDatabase: SyntaxDatabase {
        fn module_tree(key: ()) -> Arc<ModuleTreeDescriptor> {
@@ -16,7 +17,6 @@ salsa::query_group! {
    }
 }
 fn module_descriptor(db: &impl ModulesDatabase, file_id: FileId) -> Arc<ModuleDescriptor> {
    let file = db.file_syntax(file_id);
    Arc::new(ModuleDescriptor::new(file.ast()))
@@ -29,6 +29,9 @@ fn module_tree(db: &impl ModulesDatabase, (): ()) -> Arc<ModuleTreeDescriptor> {
        let module_descr = db.module_descriptor(file_id);
        files.push((file_id, module_descr));
    }
-    let res = ModuleTreeDescriptor::new(files.iter().map(|(file_id, descr)| (*file_id, &**descr)), &file_set.resolver);
+    let res = ModuleTreeDescriptor::new(
+        files.iter().map(|(file_id, descr)| (*file_id, &**descr)),
+        &file_set.resolver,
+    );
    Arc::new(res)
 }
diff --git a/crates/ra_analysis/src/roots.rs b/crates/ra_analysis/src/roots.rs
index 76bcecd38..1f2b21b27 100644
--- a/crates/ra_analysis/src/roots.rs
+++ b/crates/ra_analysis/src/roots.rs
@@ -1,22 +1,19 @@
-use std::{
+use std::{panic, sync::Arc};
-    sync::Arc,
-    panic,
-};
 use once_cell::sync::OnceCell;
-use rayon::prelude::*;
-use salsa::Database;
-use rustc_hash::{FxHashMap, FxHashSet};
 use ra_editor::LineIndex;
 use ra_syntax::File;
+use rayon::prelude::*;
+use rustc_hash::{FxHashMap, FxHashSet};
+use salsa::Database;
 use crate::{
-    FileId,
-    imp::FileResolverImp,
-    symbol_index::SymbolIndex,
-    descriptors::{ModuleDescriptor, ModuleTreeDescriptor},
    db::{self, FilesDatabase, SyntaxDatabase},
+    descriptors::{ModuleDescriptor, ModuleTreeDescriptor},
+    imp::FileResolverImp,
    module_map::ModulesDatabase,
+    symbol_index::SymbolIndex,
+    FileId,
 };
 pub(crate) trait SourceRoot {
@@ -35,7 +32,7 @@ pub(crate) struct WritableSourceRoot {
 impl WritableSourceRoot {
    pub fn apply_changes(
        &mut self,
-        changes: &mut dyn Iterator<Item=(FileId, Option<String>)>,
+        changes: &mut dyn Iterator<Item = (FileId, Option<String>)>,
        file_resolver: Option<FileResolverImp>,
    ) {
        let mut changed = FxHashSet::default();
@@ -46,22 +43,22 @@ impl WritableSourceRoot {
                    removed.insert(file_id);
                }
                Some(text) => {
-                    self.db.query(db::FileTextQuery)
+                    self.db
+                        .query(db::FileTextQuery)
                        .set(file_id, Arc::new(text));
                    changed.insert(file_id);
                }
            }
        }
        let file_set = self.db.file_set(());
-        let mut files: FxHashSet<FileId> = file_set
+        let mut files: FxHashSet<FileId> = file_set.files.clone();
-            .files
-            .clone();
        for file_id in removed {
            files.remove(&file_id);
        }
        files.extend(changed);
        let resolver = file_resolver.unwrap_or_else(|| file_set.resolver.clone());
-        self.db.query(db::FileSetQuery)
+        self.db
+            .query(db::FileSetQuery)
            .set((), Arc::new(db::FileSet { files, resolver }));
    }
 }
@@ -71,9 +68,7 @@ impl SourceRoot for WritableSourceRoot {
        self.db.module_tree(())
    }
    fn contains(&self, file_id: FileId) -> bool {
-        self.db.file_set(())
+        self.db.file_set(()).files.contains(&file_id)
-            .files
-            .contains(&file_id)
    }
    fn lines(&self, file_id: FileId) -> Arc<LineIndex> {
        self.db.file_lines(file_id)
@@ -83,7 +78,7 @@ impl SourceRoot for WritableSourceRoot {
    }
    fn symbols<'a>(&'a self, acc: &mut Vec<Arc<SymbolIndex>>) {
        let db = &self.db;
-        let symbols =  db.file_set(());
+        let symbols = db.file_set(());
        let symbols = symbols
            .files
            .iter()
@@ -108,12 +103,15 @@ impl FileData {
        }
    }
    fn lines(&self) -> &Arc<LineIndex> {
-        self.lines.get_or_init(|| Arc::new(LineIndex::new(&self.text)))
+        self.lines
+            .get_or_init(|| Arc::new(LineIndex::new(&self.text)))
    }
    fn syntax(&self) -> &File {
        let text = &self.text;
        let syntax = &self.syntax;
-        match panic::catch_unwind(panic::AssertUnwindSafe(|| syntax.get_or_init(|| File::parse(text)))) {
+        match panic::catch_unwind(panic::AssertUnwindSafe(|| {
+            syntax.get_or_init(|| File::parse(text))
+        })) {
            Ok(file) => file,
            Err(err) => {
                error!("Parser paniced on:\n------\n{}\n------\n", text);
@@ -131,22 +129,23 @@ pub(crate) struct ReadonlySourceRoot {
 }
 impl ReadonlySourceRoot {
-    pub(crate) fn new(files: Vec<(FileId, String)>, file_resolver: FileResolverImp) -> ReadonlySourceRoot {
+    pub(crate) fn new(
-        let modules = files.par_iter()
+        files: Vec<(FileId, String)>,
+        file_resolver: FileResolverImp,
+    ) -> ReadonlySourceRoot {
+        let modules = files
+            .par_iter()
            .map(|(file_id, text)| {
                let syntax = File::parse(text);
                let mod_descr = ModuleDescriptor::new(syntax.ast());
                (*file_id, syntax, mod_descr)
            })
            .collect::<Vec<_>>();
-        let module_tree = ModuleTreeDescriptor::new(
+        let module_tree =
-            modules.iter().map(|it| (it.0, &it.2)),
+            ModuleTreeDescriptor::new(modules.iter().map(|it| (it.0, &it.2)), &file_resolver);
-            &file_resolver,
-        );
-        let symbol_index = SymbolIndex::for_files(
+        let symbol_index =
-            modules.par_iter().map(|it| (it.0, it.1.clone()))
+            SymbolIndex::for_files(modules.par_iter().map(|it| (it.0, it.1.clone())));
-        );
        let file_map: FxHashMap<FileId, FileData> = files
            .into_iter()
            .map(|(id, text)| (id, FileData::new(text)))
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index 54672fde4..51eef8170 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -1,15 +1,16 @@
-use std::{
+use crate::{FileId, JobToken, Query};
-    sync::Arc,
+use fst::{self, Streamer};
-    hash::{Hash, Hasher},
+use ra_editor::{file_symbols, FileSymbol};
-};
-use ra_editor::{FileSymbol, file_symbols};
 use ra_syntax::{
    File,
    SyntaxKind::{self, *},
 };
-use fst::{self, Streamer};
 use rayon::prelude::*;
-use crate::{Query, FileId, JobToken};
+use std::{
+    hash::{Hash, Hasher},
+    sync::Arc,
+};
 #[derive(Debug)]
 pub(crate) struct SymbolIndex {
@@ -23,8 +24,7 @@ impl PartialEq for SymbolIndex {
    }
 }
-impl Eq for SymbolIndex {
+impl Eq for SymbolIndex {}
-}
 impl Hash for SymbolIndex {
    fn hash<H: Hasher>(&self, hasher: &mut H) {
@@ -33,14 +33,12 @@ impl Hash for SymbolIndex {
 }
 impl SymbolIndex {
-    pub(crate) fn for_files(files: impl ParallelIterator<Item=(FileId, File)>) -> SymbolIndex {
+    pub(crate) fn for_files(files: impl ParallelIterator<Item = (FileId, File)>) -> SymbolIndex {
        let mut symbols = files
            .flat_map(|(file_id, file)| {
                file_symbols(&file)
                    .into_iter()
-                    .map(move |symbol| {
+                    .map(move |symbol| (symbol.name.as_str().to_lowercase(), (file_id, symbol)))
-                        (symbol.name.as_str().to_lowercase(), (file_id, symbol))
-                    })
                    .collect::<Vec<_>>()
            })
            .collect::<Vec<_>>();
@@ -48,9 +46,7 @@ impl SymbolIndex {
        symbols.dedup_by(|s1, s2| s1.0 == s2.0);
        let (names, symbols): (Vec<String>, Vec<(FileId, FileSymbol)>) =
            symbols.into_iter().unzip();
-        let map = fst::Map::from_iter(
+        let map = fst::Map::from_iter(names.into_iter().zip(0u64..)).unwrap();
-            names.into_iter().zip(0u64..)
-        ).unwrap();
        SymbolIndex { symbols, map }
    }
@@ -65,7 +61,6 @@ impl Query {
        indices: &[Arc<SymbolIndex>],
        token: &JobToken,
    ) -> Vec<(FileId, FileSymbol)> {
        let mut op = fst::map::OpBuilder::new();
        for file_symbols in indices.iter() {
            let automaton = fst::automaton::Subsequence::new(&self.lowercased);
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
index 2d3679fa9..e0c637d65 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/tests.rs
@@ -1,32 +1,31 @@
-extern crate relative_path;
 extern crate ra_analysis;
-extern crate rustc_hash;
 extern crate ra_editor;
 extern crate ra_syntax;
+extern crate relative_path;
+extern crate rustc_hash;
 extern crate test_utils;
-use std::{
+use std::sync::Arc;
-    sync::Arc,
-};
-use rustc_hash::FxHashMap;
+use ra_analysis::{
+    Analysis, AnalysisHost, CrateGraph, CrateId, FileId, FileResolver, FnDescriptor, JobHandle,
+};
 use relative_path::{RelativePath, RelativePathBuf};
-use ra_analysis::{Analysis, AnalysisHost, FileId, FileResolver, JobHandle, CrateGraph, CrateId, FnDescriptor};
+use rustc_hash::FxHashMap;
 use test_utils::{assert_eq_dbg, extract_offset};
 #[derive(Debug)]
 struct FileMap(Vec<(FileId, RelativePathBuf)>);
 impl FileMap {
-    fn iter<'a>(&'a self) -> impl Iterator<Item=(FileId, &'a RelativePath)> + 'a {
+    fn iter<'a>(&'a self) -> impl Iterator<Item = (FileId, &'a RelativePath)> + 'a {
-        self.0.iter().map(|(id, path)| (*id, path.as_relative_path()))
+        self.0
+            .iter()
+            .map(|(id, path)| (*id, path.as_relative_path()))
    }
    fn path(&self, id: FileId) -> &RelativePath {
-        self.iter()
+        self.iter().find(|&(it, _)| it == id).unwrap().1
-            .find(|&(it, _)| it == id)
-            .unwrap()
-            .1
    }
 }
@@ -71,10 +70,7 @@ fn get_signature(text: &str) -> (FnDescriptor, Option<usize>) {
 #[test]
 fn test_resolve_module() {
-    let snap = analysis(&[
+    let snap = analysis(&[("/lib.rs", "mod foo;"), ("/foo.rs", "")]);
-        ("/lib.rs", "mod foo;"),
-        ("/foo.rs", "")
-    ]);
    let (_handle, token) = JobHandle::new();
    let symbols = snap.approximately_resolve_symbol(FileId(1), 4.into(), &token);
    assert_eq_dbg(
@@ -82,10 +78,7 @@ fn test_resolve_module() {
        &symbols,
    );
-    let snap = analysis(&[
+    let snap = analysis(&[("/lib.rs", "mod foo;"), ("/foo/mod.rs", "")]);
-        ("/lib.rs", "mod foo;"),
-        ("/foo/mod.rs", "")
-    ]);
    let symbols = snap.approximately_resolve_symbol(FileId(1), 4.into(), &token);
    assert_eq_dbg(
        r#"[(FileId(2), FileSymbol { name: "foo", node_range: [0; 0), kind: MODULE })]"#,
@@ -114,18 +107,12 @@ fn test_unresolved_module_diagnostic() {
 fn test_unresolved_module_diagnostic_no_diag_for_inline_mode() {
    let snap = analysis(&[("/lib.rs", "mod foo {}")]);
    let diagnostics = snap.diagnostics(FileId(1));
-    assert_eq_dbg(
+    assert_eq_dbg(r#"[]"#, &diagnostics);
-        r#"[]"#,
-        &diagnostics,
-    );
 }
 #[test]
 fn test_resolve_parent_module() {
-    let snap = analysis(&[
+    let snap = analysis(&[("/lib.rs", "mod foo;"), ("/foo.rs", "")]);
-        ("/lib.rs", "mod foo;"),
-        ("/foo.rs", ""),
-    ]);
    let symbols = snap.parent_module(FileId(2));
    assert_eq_dbg(
        r#"[(FileId(1), FileSymbol { name: "foo", node_range: [0; 8), kind: MODULE })]"#,
@@ -135,10 +122,7 @@ fn test_resolve_parent_module() {
 #[test]
 fn test_resolve_crate_root() {
-    let mut host = analysis_host(&[
+    let mut host = analysis_host(&[("/lib.rs", "mod foo;"), ("/foo.rs", "")]);
-        ("/lib.rs", "mod foo;"),
-        ("/foo.rs", ""),
-    ]);
    let snap = host.analysis();
    assert!(snap.crate_for(FileId(2)).is_empty());
@@ -152,20 +136,18 @@ fn test_resolve_crate_root() {
    host.set_crate_graph(crate_graph);
    let snap = host.analysis();
-    assert_eq!(
+    assert_eq!(snap.crate_for(FileId(2)), vec![CrateId(1)],);
-        snap.crate_for(FileId(2)),
-        vec![CrateId(1)],
-    );
 }
 #[test]
 fn test_fn_signature_two_args_first() {
    let (desc, param) = get_signature(
-r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+        r#"fn foo(x: u32, y: u32) -> u32 {x + y}
-fn bar() { foo(<|>3, ); }"#);
+fn bar() { foo(<|>3, ); }"#,
+    );
    assert_eq!(desc.name, "foo".to_string());
-    assert_eq!(desc.params, vec!("x".to_string(),"y".to_string()));
+    assert_eq!(desc.params, vec!("x".to_string(), "y".to_string()));
    assert_eq!(desc.ret_type, Some("-> u32".into()));
    assert_eq!(param, Some(0));
 }
@@ -174,10 +156,11 @@ fn bar() { foo(<|>3, ); }"#);
 fn test_fn_signature_two_args_second() {
    let (desc, param) = get_signature(
        r#"fn foo(x: u32, y: u32) -> u32 {x + y}
-fn bar() { foo(3, <|>); }"#);
+fn bar() { foo(3, <|>); }"#,
+    );
    assert_eq!(desc.name, "foo".to_string());
-    assert_eq!(desc.params, vec!("x".to_string(),"y".to_string()));
+    assert_eq!(desc.params, vec!("x".to_string(), "y".to_string()));
    assert_eq!(desc.ret_type, Some("-> u32".into()));
    assert_eq!(param, Some(1));
 }
@@ -185,8 +168,9 @@ fn bar() { foo(3, <|>); }"#);
 #[test]
 fn test_fn_signature_for_impl() {
    let (desc, param) = get_signature(
-r#"struct F; impl F { pub fn new() { F{}} }
+        r#"struct F; impl F { pub fn new() { F{}} }
-fn bar() {let _ : F = F::new(<|>);}"#);
+fn bar() {let _ : F = F::new(<|>);}"#,
+    );
    assert_eq!(desc.name, "new".to_string());
    assert_eq!(desc.params, Vec::<String>::new());
@@ -197,7 +181,7 @@ fn bar() {let _ : F = F::new(<|>);}"#);
 #[test]
 fn test_fn_signature_for_method_self() {
    let (desc, param) = get_signature(
-r#"struct F;
+        r#"struct F;
 impl F {
    pub fn new() -> F{
        F{}
@@ -209,7 +193,8 @@ impl F {
 fn bar() {
    let f : F = F::new();
    f.do_it(<|>);
-}"#);
+}"#,
+    );
    assert_eq!(desc.name, "do_it".to_string());
    assert_eq!(desc.params, vec!["&self".to_string()]);
@@ -220,7 +205,7 @@ fn bar() {
 #[test]
 fn test_fn_signature_for_method_with_arg() {
    let (desc, param) = get_signature(
-r#"struct F;
+        r#"struct F;
 impl F {
    pub fn new() -> F{
        F{}
@@ -232,7 +217,8 @@ impl F {
 fn bar() {
    let f : F = F::new();
    f.do_it(<|>);
-}"#);
+}"#,
+    );
    assert_eq!(desc.name, "do_it".to_string());
    assert_eq!(desc.params, vec!["&self".to_string(), "x".to_string()]);
diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index 11605cfd8..239d846b3 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -2,19 +2,17 @@ extern crate clap;
 #[macro_use]
 extern crate failure;
 extern crate join_to_string;
-extern crate ra_syntax;
 extern crate ra_editor;
+extern crate ra_syntax;
 extern crate tools;
-use std::{
+use std::{fs, io::Read, path::Path, time::Instant};
-    fs, io::Read, path::Path,
-    time::Instant
-};
 use clap::{App, Arg, SubCommand};
 use join_to_string::join;
+use ra_editor::{extend_selection, file_structure, syntax_tree};
+use ra_syntax::{File, TextRange};
 use tools::collect_tests;
-use ra_syntax::{TextRange, File};
-use ra_editor::{syntax_tree, file_structure, extend_selection};
 type Result<T> = ::std::result::Result<T, failure::Error>;
@@ -36,14 +34,12 @@ fn main() -> Result<()> {
                        .takes_value(true),
                ),
        )
-        .subcommand(
+        .subcommand(SubCommand::with_name("parse").arg(Arg::with_name("no-dump").long("--no-dump")))
-            SubCommand::with_name("parse")
-                .arg(Arg::with_name("no-dump").long("--no-dump"))
-        )
        .subcommand(SubCommand::with_name("symbols"))
-        .subcommand(SubCommand::with_name("extend-selection")
+        .subcommand(
-            .arg(Arg::with_name("start"))
+            SubCommand::with_name("extend-selection")
-            .arg(Arg::with_name("end"))
+                .arg(Arg::with_name("start"))
+                .arg(Arg::with_name("end")),
        )
        .get_matches();
    match matches.subcommand() {
@@ -116,7 +112,8 @@ fn selections(file: &File, start: u32, end: u32) -> String {
        ranges.push(r);
        cur = extend_selection(&file, r);
    }
-    let ranges = ranges.iter()
+    let ranges = ranges
+        .iter()
        .map(|r| (1 + u32::from(r.start()), 1 + u32::from(r.end())))
        .map(|(s, e)| format!("({} {})", s, e));
    join(ranges)
diff --git a/crates/ra_editor/src/code_actions.rs b/crates/ra_editor/src/code_actions.rs
index 7b0a48c81..cadcd2720 100644
--- a/crates/ra_editor/src/code_actions.rs
+++ b/crates/ra_editor/src/code_actions.rs
@@ -1,17 +1,14 @@
 use join_to_string::join;
 use ra_syntax::{
-    File, TextUnit, TextRange, Direction,
+    algo::{find_covering_node, find_leaf_at_offset},
-    ast::{self, AstNode, AttrsOwner, TypeParamsOwner, NameOwner},
+    ast::{self, AstNode, AttrsOwner, NameOwner, TypeParamsOwner},
+    Direction, File,
    SyntaxKind::{COMMA, WHITESPACE},
-    SyntaxNodeRef,
+    SyntaxNodeRef, TextRange, TextUnit,
-    algo::{
-        find_leaf_at_offset,
-        find_covering_node,
-    },
 };
-use crate::{EditBuilder, Edit, find_node_at_offset};
+use crate::{find_node_at_offset, Edit, EditBuilder};
 #[derive(Debug)]
 pub struct LocalEdit {
@@ -52,9 +49,7 @@ pub fn add_derive<'a>(file: &'a File, offset: TextUnit) -> Option<impl FnOnce()
                edit.insert(node_start, "#[derive()]\n".to_string());
                node_start + TextUnit::of_str("#[derive(")
            }
-            Some(tt) => {
+            Some(tt) => tt.syntax().range().end() - TextUnit::of_char(')'),
-                tt.syntax().range().end() - TextUnit::of_char(')')
-            }
        };
        LocalEdit {
            edit: edit.finish(),
@@ -74,14 +69,19 @@ pub fn add_impl<'a>(file: &'a File, offset: TextUnit) -> Option<impl FnOnce() ->
        let mut buf = String::new();
        buf.push_str("\n\nimpl");
        if let Some(type_params) = type_params {
-            type_params.syntax().text()
+            type_params.syntax().text().push_to(&mut buf);
-                .push_to(&mut buf);
        }
        buf.push_str(" ");
        buf.push_str(name.text().as_str());
        if let Some(type_params) = type_params {
-            let lifetime_params = type_params.lifetime_params().filter_map(|it| it.lifetime()).map(|it| it.text());
+            let lifetime_params = type_params
-            let type_params = type_params.type_params().filter_map(|it| it.name()).map(|it| it.text());
+                .lifetime_params()
+                .filter_map(|it| it.lifetime())
+                .map(|it| it.text());
+            let type_params = type_params
+                .type_params()
+                .filter_map(|it| it.name())
+                .map(|it| it.text());
            join(lifetime_params.chain(type_params))
                .surround_with("<", ">")
                .to_buf(&mut buf);
@@ -97,10 +97,17 @@ pub fn add_impl<'a>(file: &'a File, offset: TextUnit) -> Option<impl FnOnce() ->
    })
 }
-pub fn introduce_variable<'a>(file: &'a File, range: TextRange) -> Option<impl FnOnce() -> LocalEdit + 'a> {
+pub fn introduce_variable<'a>(
+    file: &'a File,
+    range: TextRange,
+) -> Option<impl FnOnce() -> LocalEdit + 'a> {
    let node = find_covering_node(file.syntax(), range);
    let expr = node.ancestors().filter_map(ast::Expr::cast).next()?;
-    let anchor_stmt = expr.syntax().ancestors().filter_map(ast::Stmt::cast).next()?;
+    let anchor_stmt = expr
+        .syntax()
+        .ancestors()
+        .filter_map(ast::Stmt::cast)
+        .next()?;
    let indent = anchor_stmt.syntax().prev_sibling()?;
    if indent.kind() != WHITESPACE {
        return None;
@@ -191,7 +198,8 @@ mod tests {
            "
 fn foo() {
    foo(<|>1 + 1<|>);
-}", "
+}",
+            "
 fn foo() {
    let <|>var_name = 1 + 1;
    foo(var_name);
@@ -201,11 +209,12 @@ fn foo() {
    }
    #[test]
    fn test_intrdoduce_var_expr_stmt() {
-check_action_range(
+        check_action_range(
            "
 fn foo() {
    <|>1 + 1<|>;
-}", "
+}",
+            "
 fn foo() {
    let <|>var_name = 1 + 1;
 }",
diff --git a/crates/ra_editor/src/completion.rs b/crates/ra_editor/src/completion.rs
index b6095dca9..86ef46ebd 100644
--- a/crates/ra_editor/src/completion.rs
+++ b/crates/ra_editor/src/completion.rs
@@ -1,17 +1,18 @@
 use rustc_hash::{FxHashMap, FxHashSet};
 use ra_syntax::{
-    File, TextUnit, AstNode, SyntaxNodeRef, SyntaxKind::*,
+    algo::visit::{visitor, visitor_ctx, Visitor, VisitorCtx},
    ast::{self, LoopBodyOwner, ModuleItemOwner},
-    algo::{
-        visit::{visitor, Visitor, visitor_ctx, VisitorCtx},
-    },
    text_utils::is_subrange,
+    AstNode, File,
+    SyntaxKind::*,
+    SyntaxNodeRef, TextUnit,
 };
 use crate::{
-    AtomEdit, find_node_at_offset,
+    find_node_at_offset,
    scope::{FnScopes, ModuleScope},
+    AtomEdit,
 };
 #[derive(Debug)]
@@ -21,7 +22,7 @@ pub struct CompletionItem {
    /// What string is used for filtering, defaults to label
    pub lookup: Option<String>,
    /// What is inserted, defaults to label
-    pub snippet: Option<String>
+    pub snippet: Option<String>,
 }
 pub fn scope_completion(file: &File, offset: TextUnit) -> Option<Vec<CompletionItem>> {
@@ -40,7 +41,12 @@ pub fn scope_completion(file: &File, offset: TextUnit) -> Option<Vec<CompletionI
            param_completions(name_ref.syntax(), &mut res);
        }
        let name_range = name_ref.syntax().range();
-        let top_node = name_ref.syntax().ancestors().take_while(|it| it.range() == name_range).last().unwrap();
+        let top_node = name_ref
+            .syntax()
+            .ancestors()
+            .take_while(|it| it.range() == name_range)
+            .last()
+            .unwrap();
        match top_node.parent().map(|it| it.kind()) {
            Some(ROOT) | Some(ITEM_LIST) => complete_mod_item_snippets(&mut res),
            _ => (),
@@ -68,21 +74,23 @@ fn complete_name_ref(file: &File, name_ref: ast::NameRef, acc: &mut Vec<Completi
        if let Some(items) = visitor()
            .visit::<ast::Root, _>(|it| Some(it.items()))
            .visit::<ast::Module, _>(|it| Some(it.item_list()?.items()))
-            .accept(node) {
+            .accept(node)
+        {
            if let Some(items) = items {
                let scope = ModuleScope::new(items);
                acc.extend(
-                    scope.entries().iter()
+                    scope
+                        .entries()
+                        .iter()
                        .filter(|entry| entry.syntax() != name_ref.syntax())
                        .map(|entry| CompletionItem {
                            label: entry.name().to_string(),
                            lookup: None,
                            snippet: None,
-                        })
+                        }),
                );
            }
            break;
        } else if !visited_fn {
            if let Some(fn_def) = ast::FnDef::cast(node) {
                visited_fn = true;
@@ -103,26 +111,34 @@ fn param_completions(ctx: SyntaxNodeRef, acc: &mut Vec<CompletionItem>) {
            .visit::<ast::ItemList, _>(process)
            .accept(node);
    }
-    params.into_iter()
+    params
+        .into_iter()
        .filter_map(|(label, (count, param))| {
            let lookup = param.pat()?.syntax().text().to_string();
-            if count < 2 { None } else { Some((label, lookup)) }
+            if count < 2 {
+                None
+            } else {
+                Some((label, lookup))
+            }
        })
        .for_each(|(label, lookup)| {
            acc.push(CompletionItem {
-                label, lookup: Some(lookup), snippet: None
+                label,
+                lookup: Some(lookup),
+                snippet: None,
            })
        });
-    fn process<'a, N: ast::FnDefOwner<'a>>(node: N, params: &mut FxHashMap<String, (u32, ast::Param<'a>)>) {
+    fn process<'a, N: ast::FnDefOwner<'a>>(
+        node: N,
+        params: &mut FxHashMap<String, (u32, ast::Param<'a>)>,
+    ) {
        node.functions()
            .filter_map(|it| it.param_list())
            .flat_map(|it| it.params())
            .for_each(|param| {
                let text = param.syntax().text().to_string();
-                params.entry(text)
+                params.entry(text).or_insert((0, param)).0 += 1;
-                      .or_insert((0, param))
-                      .0 += 1;
            })
    }
 }
@@ -134,8 +150,12 @@ fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
    }
 }
+fn complete_expr_keywords(
-fn complete_expr_keywords(file: &File, fn_def: ast::FnDef, name_ref: ast::NameRef, acc: &mut Vec<CompletionItem>) {
+    file: &File,
+    fn_def: ast::FnDef,
+    name_ref: ast::NameRef,
+    acc: &mut Vec<CompletionItem>,
+) {
    acc.push(keyword("if", "if $0 {}"));
    acc.push(keyword("match", "match $0 {}"));
    acc.push(keyword("while", "while $0 {}"));
@@ -186,9 +206,14 @@ fn complete_return(fn_def: ast::FnDef, name_ref: ast::NameRef) -> Option<Complet
    //     return None;
    // }
-    let is_stmt = match name_ref.syntax().ancestors().filter_map(ast::ExprStmt::cast).next() {
+    let is_stmt = match name_ref
+        .syntax()
+        .ancestors()
+        .filter_map(ast::ExprStmt::cast)
+        .next()
+    {
        None => false,
-        Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range()
+        Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(),
    };
    let snip = match (is_stmt, fn_def.ret_type().is_some()) {
        (true, true) => "return $0;",
@@ -209,39 +234,37 @@ fn keyword(kw: &str, snip: &str) -> CompletionItem {
 fn complete_expr_snippets(acc: &mut Vec<CompletionItem>) {
    acc.push(CompletionItem {
-            label: "pd".to_string(),
+        label: "pd".to_string(),
-            lookup: None,
+        lookup: None,
-            snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()),
+        snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()),
-        }
+    });
-    );
    acc.push(CompletionItem {
-            label: "ppd".to_string(),
+        label: "ppd".to_string(),
-            lookup: None,
+        lookup: None,
-            snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()),
+        snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()),
-        }
+    });
-    );
 }
 fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
    acc.push(CompletionItem {
-            label: "tfn".to_string(),
+        label: "tfn".to_string(),
-            lookup: None,
+        lookup: None,
-            snippet: Some("#[test]\nfn $1() {\n    $0\n}".to_string()),
+        snippet: Some("#[test]\nfn $1() {\n    $0\n}".to_string()),
-        }
+    });
-    );
 }
 fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
    let mut shadowed = FxHashSet::default();
    acc.extend(
-        scopes.scope_chain(name_ref.syntax())
+        scopes
+            .scope_chain(name_ref.syntax())
            .flat_map(|scope| scopes.entries(scope).iter())
            .filter(|entry| shadowed.insert(entry.name()))
            .map(|entry| CompletionItem {
                label: entry.name().to_string(),
                lookup: None,
                snippet: None,
-            })
+            }),
    );
    if scopes.self_param.is_some() {
        acc.push(CompletionItem {
@@ -281,20 +304,24 @@ mod tests {
    #[test]
    fn test_completion_let_scope() {
-        check_scope_completion(r"
+        check_scope_completion(
+            r"
            fn quux(x: i32) {
                let y = 92;
                1 + <|>;
                let z = ();
            }
-            ", r#"[CompletionItem { label: "y", lookup: None, snippet: None },
+            ",
+            r#"[CompletionItem { label: "y", lookup: None, snippet: None },
                   CompletionItem { label: "x", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#);
+                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
+        );
    }
    #[test]
    fn test_completion_if_let_scope() {
-        check_scope_completion(r"
+        check_scope_completion(
+            r"
            fn quux() {
                if let Some(x) = foo() {
                    let y = 92;
@@ -304,67 +331,85 @@ mod tests {
                    1 + <|>
                }
            }
-            ", r#"[CompletionItem { label: "b", lookup: None, snippet: None },
+            ",
+            r#"[CompletionItem { label: "b", lookup: None, snippet: None },
                   CompletionItem { label: "a", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#);
+                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
+        );
    }
    #[test]
    fn test_completion_for_scope() {
-        check_scope_completion(r"
+        check_scope_completion(
+            r"
            fn quux() {
                for x in &[1, 2, 3] {
                    <|>
                }
            }
-            ", r#"[CompletionItem { label: "x", lookup: None, snippet: None },
+            ",
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#);
+            r#"[CompletionItem { label: "x", lookup: None, snippet: None },
+                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
+        );
    }
    #[test]
    fn test_completion_mod_scope() {
-        check_scope_completion(r"
+        check_scope_completion(
+            r"
            struct Foo;
            enum Baz {}
            fn quux() {
                <|>
            }
-            ", r#"[CompletionItem { label: "Foo", lookup: None, snippet: None },
+            ",
+            r#"[CompletionItem { label: "Foo", lookup: None, snippet: None },
                   CompletionItem { label: "Baz", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#);
+                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
+        );
    }
    #[test]
    fn test_completion_mod_scope_no_self_use() {
-        check_scope_completion(r"
+        check_scope_completion(
+            r"
            use foo<|>;
-            ", r#"[]"#);
+            ",
+            r#"[]"#,
+        );
    }
    #[test]
    fn test_completion_mod_scope_nested() {
-        check_scope_completion(r"
+        check_scope_completion(
+            r"
            struct Foo;
            mod m {
                struct Bar;
                fn quux() { <|> }
            }
-            ", r#"[CompletionItem { label: "Bar", lookup: None, snippet: None },
+            ",
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#);
+            r#"[CompletionItem { label: "Bar", lookup: None, snippet: None },
+                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
+        );
    }
    #[test]
    fn test_complete_type() {
-        check_scope_completion(r"
+        check_scope_completion(
+            r"
            struct Foo;
            fn x() -> <|>
-        ", r#"[CompletionItem { label: "Foo", lookup: None, snippet: None },
+        ",
-               CompletionItem { label: "x", lookup: None, snippet: None }]"#)
+            r#"[CompletionItem { label: "Foo", lookup: None, snippet: None },
+               CompletionItem { label: "x", lookup: None, snippet: None }]"#,
+        )
    }
    #[test]
    fn test_complete_shadowing() {
-        check_scope_completion(r"
+        check_scope_completion(
+            r"
            fn foo() -> {
                let bar = 92;
                {
@@ -372,15 +417,20 @@ mod tests {
                    <|>
                }
            }
-        ", r#"[CompletionItem { label: "bar", lookup: None, snippet: None },
+        ",
-               CompletionItem { label: "foo", lookup: None, snippet: None }]"#)
+            r#"[CompletionItem { label: "bar", lookup: None, snippet: None },
+               CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
+        )
    }
    #[test]
    fn test_complete_self() {
-        check_scope_completion(r"
+        check_scope_completion(
+            r"
            impl S { fn foo(&self) { <|> } }
-        ", r#"[CompletionItem { label: "self", lookup: None, snippet: None }]"#)
+        ",
+            r#"[CompletionItem { label: "self", lookup: None, snippet: None }]"#,
+        )
    }
    #[test]
diff --git a/crates/ra_editor/src/edit.rs b/crates/ra_editor/src/edit.rs
index 46e687319..c3149ec54 100644
--- a/crates/ra_editor/src/edit.rs
+++ b/crates/ra_editor/src/edit.rs
@@ -1,8 +1,5 @@
 use crate::{TextRange, TextUnit};
-use ra_syntax::{
+use ra_syntax::{text_utils::contains_offset_nonstrict, AtomEdit};
-    AtomEdit,
-    text_utils::contains_offset_nonstrict,
-};
 #[derive(Debug, Clone)]
 pub struct Edit {
@@ -11,7 +8,7 @@ pub struct Edit {
 #[derive(Debug)]
 pub struct EditBuilder {
-    atoms: Vec<AtomEdit>
+    atoms: Vec<AtomEdit>,
 }
 impl EditBuilder {
@@ -36,7 +33,9 @@ impl EditBuilder {
        Edit { atoms }
    }
    pub fn invalidates_offset(&self, offset: TextUnit) -> bool {
-        self.atoms.iter().any(|atom| contains_offset_nonstrict(atom.delete, offset))
+        self.atoms
+            .iter()
+            .any(|atom| contains_offset_nonstrict(atom.delete, offset))
    }
 }
@@ -74,7 +73,7 @@ impl Edit {
                break;
            }
            if offset < atom.delete.end() {
-                return None
+                return None;
            }
            res += TextUnit::of_str(&atom.insert);
            res -= atom.delete.len();
diff --git a/crates/ra_editor/src/extend_selection.rs b/crates/ra_editor/src/extend_selection.rs
index ab03a717e..9ee1df281 100644
--- a/crates/ra_editor/src/extend_selection.rs
+++ b/crates/ra_editor/src/extend_selection.rs
@@ -1,7 +1,8 @@
 use ra_syntax::{
-    File, TextRange, SyntaxNodeRef, TextUnit, Direction,
+    algo::{find_covering_node, find_leaf_at_offset, LeafAtOffset},
+    Direction, File,
    SyntaxKind::*,
-    algo::{find_leaf_at_offset, LeafAtOffset, find_covering_node},
+    SyntaxNodeRef, TextRange, TextUnit,
 };
 pub fn extend_selection(file: &File, range: TextRange) -> Option<TextRange> {
@@ -20,11 +21,11 @@ pub(crate) fn extend(root: SyntaxNodeRef, range: TextRange) -> Option<TextRange>
            LeafAtOffset::None => return None,
            LeafAtOffset::Single(l) => {
                if l.kind() == COMMENT {
-                    extend_single_word_in_comment(l, offset).unwrap_or_else(||l.range())
+                    extend_single_word_in_comment(l, offset).unwrap_or_else(|| l.range())
                } else {
                    l.range()
                }
-            },
+            }
            LeafAtOffset::Between(l, r) => pick_best(l, r).range(),
        };
        return Some(leaf_range);
@@ -66,7 +67,7 @@ fn extend_ws(root: SyntaxNodeRef, ws: SyntaxNodeRef, offset: TextUnit) -> TextRa
        if let Some(node) = ws.next_sibling() {
            let start = match ws_prefix.rfind('\n') {
                Some(idx) => ws.range().start() + TextUnit::from((idx + 1) as u32),
-                None => node.range().start()
+                None => node.range().start(),
            };
            let end = if root.text().char_at(node.range().end()) == Some('\n') {
                node.range().end() + TextUnit::of_char('\n')
@@ -94,10 +95,7 @@ fn extend_comments(node: SyntaxNodeRef) -> Option<TextRange> {
    let prev = adj_comments(node, Direction::Prev);
    let next = adj_comments(node, Direction::Next);
    if prev != next {
-        Some(TextRange::from_to(
+        Some(TextRange::from_to(prev.range().start(), next.range().end()))
-            prev.range().start(),
-            next.range().end(),
-        ))
    } else {
        None
    }
@@ -109,7 +107,7 @@ fn adj_comments(node: SyntaxNodeRef, dir: Direction) -> SyntaxNodeRef {
        match node.kind() {
            COMMENT => res = node,
            WHITESPACE if !node.leaf_text().unwrap().as_str().contains("\n\n") => (),
-            _ => break
+            _ => break,
        }
    }
    res
@@ -125,8 +123,7 @@ mod tests {
        let file = File::parse(&before);
        let mut range = TextRange::offset_len(cursor, 0.into());
        for &after in afters {
-            range = extend_selection(&file, range)
+            range = extend_selection(&file, range).unwrap();
-                .unwrap();
            let actual = &before[range];
            assert_eq!(after, actual);
        }
@@ -134,10 +131,7 @@ mod tests {
    #[test]
    fn test_extend_selection_arith() {
-        do_check(
+        do_check(r#"fn foo() { <|>1 + 1 }"#, &["1", "1 + 1", "{ 1 + 1 }"]);
-            r#"fn foo() { <|>1 + 1 }"#,
-            &["1", "1 + 1", "{ 1 + 1 }"],
-        );
    }
    #[test]
@@ -149,7 +143,7 @@ impl S {
    }
 }"#,
-            &["    fn foo() {\n\n    }\n"]
+            &["    fn foo() {\n\n    }\n"],
        );
    }
@@ -165,7 +159,11 @@ struct B {
    <|>
 }
            "#,
-            &["\n    \n", "{\n    \n}", "/// bla\n/// bla\nstruct B {\n    \n}"]
+            &[
+                "\n    \n",
+                "{\n    \n}",
+                "/// bla\n/// bla\nstruct B {\n    \n}",
+            ],
        )
    }
@@ -181,7 +179,7 @@ fn bar(){}
 // fn foo(){}
    "#,
-            &["// 1 + 1", "// fn foo() {\n// 1 + 1\n// }"]
+            &["// 1 + 1", "// fn foo() {\n// 1 + 1\n// }"],
        );
    }
@@ -191,42 +189,34 @@ fn bar(){}
            r#"
 fn main() { foo<|>+bar;}
    "#,
-            &["foo", "foo+bar"]
+            &["foo", "foo+bar"],
        );
        do_check(
            r#"
 fn main() { foo+<|>bar;}
    "#,
-            &["bar", "foo+bar"]
+            &["bar", "foo+bar"],
        );
    }
    #[test]
    fn test_extend_selection_prefer_lifetimes() {
-        do_check(
+        do_check(r#"fn foo<<|>'a>() {}"#, &["'a", "<'a>"]);
-            r#"fn foo<<|>'a>() {}"#,
+        do_check(r#"fn foo<'a<|>>() {}"#, &["'a", "<'a>"]);
-            &["'a", "<'a>"]
-        );
-        do_check(
-            r#"fn foo<'a<|>>() {}"#,
-            &["'a", "<'a>"]
-        );
    }
    #[test]
    fn test_extend_selection_select_first_word() {
+        do_check(r#"// foo bar b<|>az quxx"#, &["baz", "// foo bar baz quxx"]);
        do_check(
-            r#"// foo bar b<|>az quxx"#,
+            r#"
-            &["baz", "// foo bar baz quxx"]
-        );
-        do_check(r#"
 impl S {
    fn foo() {
        // hel<|>lo world
    }
 }
        "#,
-            &["hello", "// hello world"]
+            &["hello", "// hello world"],
        );
    }
 }
diff --git a/crates/ra_editor/src/folding_ranges.rs b/crates/ra_editor/src/folding_ranges.rs
index a1699d449..e5bc0c4ee 100644
--- a/crates/ra_editor/src/folding_ranges.rs
+++ b/crates/ra_editor/src/folding_ranges.rs
@@ -1,11 +1,9 @@
 use rustc_hash::FxHashSet;
 use ra_syntax::{
-    ast,
+    ast, AstNode, Direction, File,
-    AstNode,
-    File, TextRange, SyntaxNodeRef,
    SyntaxKind::{self, *},
-    Direction,
+    SyntaxNodeRef, TextRange,
 };
 #[derive(Debug, PartialEq, Eq)]
@@ -28,7 +26,10 @@ pub fn folding_ranges(file: &File) -> Vec<Fold> {
        // Fold items that span multiple lines
        if let Some(kind) = fold_kind(node.kind()) {
            if has_newline(node) {
-                res.push(Fold { range: node.range(), kind });
+                res.push(Fold {
+                    range: node.range(),
+                    kind,
+                });
            }
        }
@@ -37,8 +38,12 @@ pub fn folding_ranges(file: &File) -> Vec<Fold> {
            continue;
        }
        if node.kind() == COMMENT {
-            contiguous_range_for_comment(node, &mut visited_comments)
+            contiguous_range_for_comment(node, &mut visited_comments).map(|range| {
-                .map(|range| res.push(Fold { range, kind: FoldKind::Comment }));
+                res.push(Fold {
+                    range,
+                    kind: FoldKind::Comment,
+                })
+            });
        }
    }
@@ -49,13 +54,11 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
    match kind {
        COMMENT => Some(FoldKind::Comment),
        USE_ITEM => Some(FoldKind::Imports),
-        _ => None
+        _ => None,
    }
 }
-fn has_newline(
+fn has_newline(node: SyntaxNodeRef) -> bool {
-    node: SyntaxNodeRef,
-) -> bool {
    for descendant in node.descendants() {
        if let Some(ws) = ast::Whitespace::cast(descendant) {
            if ws.has_newlines() {
@@ -100,9 +103,7 @@ fn contiguous_range_for_comment<'a>(
            // The comment group ends because either:
            // * An element of a different kind was reached
            // * A comment of a different flavor was reached
-            _ => {
+            _ => break,
-                break
-            }
        }
    }
@@ -128,7 +129,11 @@ mod tests {
        let folds = folding_ranges(&file);
        assert_eq!(folds.len(), ranges.len());
-        for ((fold, range), fold_kind) in folds.into_iter().zip(ranges.into_iter()).zip(fold_kinds.into_iter()) {
+        for ((fold, range), fold_kind) in folds
+            .into_iter()
+            .zip(ranges.into_iter())
+            .zip(fold_kinds.into_iter())
+        {
            assert_eq!(fold.range.start(), range.start());
            assert_eq!(fold.range.end(), range.end());
            assert_eq!(&fold.kind, fold_kind);
@@ -181,5 +186,4 @@ fn main() {
        do_check(text, folds);
    }
 }
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
index bd61fd191..417080d90 100644
--- a/crates/ra_editor/src/lib.rs
+++ b/crates/ra_editor/src/lib.rs
@@ -1,44 +1,41 @@
-extern crate ra_syntax;
-extern crate superslice;
 extern crate itertools;
 extern crate join_to_string;
+extern crate ra_syntax;
 extern crate rustc_hash;
+extern crate superslice;
 #[cfg(test)]
 #[macro_use]
 extern crate test_utils as _test_utils;
-mod extend_selection;
-mod symbols;
-mod line_index;
-mod edit;
-mod folding_ranges;
 mod code_actions;
-mod typing;
 mod completion;
+mod edit;
+mod extend_selection;
+mod folding_ranges;
+mod line_index;
 mod scope;
+mod symbols;
 #[cfg(test)]
 mod test_utils;
+mod typing;
+pub use self::{
+    code_actions::{add_derive, add_impl, flip_comma, introduce_variable, LocalEdit},
+    completion::{scope_completion, CompletionItem},
+    edit::{Edit, EditBuilder},
+    extend_selection::extend_selection,
+    folding_ranges::{folding_ranges, Fold, FoldKind},
+    line_index::{LineCol, LineIndex},
+    symbols::{file_structure, file_symbols, FileSymbol, StructureNode},
+    typing::{join_lines, on_enter, on_eq_typed},
+};
+pub use ra_syntax::AtomEdit;
 use ra_syntax::{
-    File, TextUnit, TextRange, SmolStr, SyntaxNodeRef,
-    ast::{self, AstNode, NameOwner},
    algo::find_leaf_at_offset,
+    ast::{self, AstNode, NameOwner},
+    File, SmolStr,
    SyntaxKind::{self, *},
-};
+    SyntaxNodeRef, TextRange, TextUnit,
-pub use ra_syntax::AtomEdit;
-pub use self::{
-    line_index::{LineIndex, LineCol},
-    extend_selection::extend_selection,
-    symbols::{StructureNode, file_structure, FileSymbol, file_symbols},
-    edit::{EditBuilder, Edit},
-    code_actions::{
-        LocalEdit,
-        flip_comma, add_derive, add_impl,
-        introduce_variable,
-    },
-    typing::{join_lines, on_eq_typed, on_enter},
-    completion::{scope_completion, CompletionItem},
-    folding_ranges::{Fold, FoldKind, folding_ranges}
 };
 #[derive(Debug)]
@@ -67,10 +64,7 @@ pub enum RunnableKind {
 pub fn matching_brace(file: &File, offset: TextUnit) -> Option<TextUnit> {
    const BRACES: &[SyntaxKind] = &[
-        L_CURLY, R_CURLY,
+        L_CURLY, R_CURLY, L_BRACK, R_BRACK, L_PAREN, R_PAREN, L_ANGLE, R_ANGLE,
-        L_BRACK, R_BRACK,
-        L_PAREN, R_PAREN,
-        L_ANGLE, R_ANGLE,
    ];
    let (brace_node, brace_idx) = find_leaf_at_offset(file.syntax(), offset)
        .filter_map(|node| {
@@ -80,7 +74,8 @@ pub fn matching_brace(file: &File, offset: TextUnit) -> Option<TextUnit> {
        .next()?;
    let parent = brace_node.parent()?;
    let matching_kind = BRACES[brace_idx ^ 1];
-    let matching_node = parent.children()
+    let matching_node = parent
+        .children()
        .find(|node| node.kind() == matching_kind)?;
    Some(matching_node.range().start())
 }
@@ -108,10 +103,13 @@ pub fn highlight(file: &File) -> Vec<HighlightedRange> {
 }
 pub fn diagnostics(file: &File) -> Vec<Diagnostic> {
-    file.errors().into_iter().map(|err| Diagnostic {
+    file.errors()
-        range: TextRange::offset_len(err.offset, 1.into()),
+        .into_iter()
-        msg: "Syntax Error: ".to_string() + &err.msg,
+        .map(|err| Diagnostic {
-    }).collect()
+            range: TextRange::offset_len(err.offset, 1.into()),
+            msg: "Syntax Error: ".to_string() + &err.msg,
+        })
+        .collect()
 }
 pub fn syntax_tree(file: &File) -> String {
@@ -119,7 +117,8 @@ pub fn syntax_tree(file: &File) -> String {
 }
 pub fn runnables(file: &File) -> Vec<Runnable> {
-    file.syntax().descendants()
+    file.syntax()
+        .descendants()
        .filter_map(ast::FnDef::cast)
        .filter_map(|f| {
            let name = f.name()?.text();
@@ -127,7 +126,7 @@ pub fn runnables(file: &File) -> Vec<Runnable> {
                RunnableKind::Bin
            } else if f.has_atom_attr("test") {
                RunnableKind::Test {
-                    name: name.to_string()
+                    name: name.to_string(),
                }
            } else {
                return None;
@@ -145,15 +144,18 @@ pub fn find_node_at_offset<'a, N: AstNode<'a>>(
    offset: TextUnit,
 ) -> Option<N> {
    let leaves = find_leaf_at_offset(syntax, offset);
-    let leaf = leaves.clone()
+    let leaf = leaves
+        .clone()
        .find(|leaf| !leaf.kind().is_trivia())
        .or_else(|| leaves.right_biased())?;
-    leaf.ancestors()
+    leaf.ancestors().filter_map(N::cast).next()
-        .filter_map(N::cast)
-        .next()
 }
-pub fn resolve_local_name(file: &File, offset: TextUnit, name_ref: ast::NameRef) -> Option<(SmolStr, TextRange)> {
+pub fn resolve_local_name(
+    file: &File,
+    offset: TextUnit,
+    name_ref: ast::NameRef,
+) -> Option<(SmolStr, TextRange)> {
    let fn_def = find_node_at_offset::<ast::FnDef>(file.syntax(), offset)?;
    let scopes = scope::FnScopes::new(fn_def);
    let scope_entry = scope::resolve_local_name(name_ref, &scopes)?;
@@ -164,15 +166,17 @@ pub fn resolve_local_name(file: &File, offset: TextUnit, name_ref: ast::NameRef)
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::test_utils::{assert_eq_dbg, extract_offset, add_cursor};
+    use crate::test_utils::{add_cursor, assert_eq_dbg, extract_offset};
    #[test]
    fn test_highlighting() {
-        let file = File::parse(r#"
+        let file = File::parse(
+            r#"
 // comment
 fn main() {}
    println!("Hello, {}!", 92);
-"#);
+"#,
+        );
        let hls = highlight(&file);
        assert_eq_dbg(
            r#"[HighlightedRange { range: [1; 11), tag: "comment" },
@@ -187,7 +191,8 @@ fn main() {}
    #[test]
    fn test_runnables() {
-      let file = File::parse(r#"
+        let file = File::parse(
+            r#"
 fn main() {}
 #[test]
@@ -196,7 +201,8 @@ fn test_foo() {}
 #[test]
 #[ignore]
 fn test_foo() {}
-"#);
+"#,
+        );
        let runnables = runnables(&file);
        assert_eq_dbg(
            r#"[Runnable { range: [1; 13), kind: Bin },
@@ -219,9 +225,6 @@ fn test_foo() {}
            assert_eq_text!(after, &actual);
        }
-        do_check(
+        do_check("struct Foo { a: i32, }<|>", "struct Foo <|>{ a: i32, }");
-            "struct Foo { a: i32, }<|>",
-            "struct Foo <|>{ a: i32, }",
-        );
    }
 }
diff --git a/crates/ra_editor/src/line_index.rs b/crates/ra_editor/src/line_index.rs
index 95d64b8a8..da0f2a7f7 100644
--- a/crates/ra_editor/src/line_index.rs
+++ b/crates/ra_editor/src/line_index.rs
@@ -1,5 +1,5 @@
-use superslice::Ext;
 use crate::TextUnit;
+use superslice::Ext;
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct LineIndex {
@@ -29,7 +29,10 @@ impl LineIndex {
        let line = self.newlines.upper_bound(&offset) - 1;
        let line_start_offset = self.newlines[line];
        let col = offset - line_start_offset;
-        return LineCol { line: line as u32, col };
+        return LineCol {
+            line: line as u32,
+            col,
+        };
    }
    pub fn offset(&self, line_col: LineCol) -> TextUnit {
@@ -42,21 +45,105 @@ impl LineIndex {
 fn test_line_index() {
    let text = "hello\nworld";
    let index = LineIndex::new(text);
-    assert_eq!(index.line_col(0.into()), LineCol { line: 0, col: 0.into() });
+    assert_eq!(
-    assert_eq!(index.line_col(1.into()), LineCol { line: 0, col: 1.into() });
+        index.line_col(0.into()),
-    assert_eq!(index.line_col(5.into()), LineCol { line: 0, col: 5.into() });
+        LineCol {
-    assert_eq!(index.line_col(6.into()), LineCol { line: 1, col: 0.into() });
+            line: 0,
-    assert_eq!(index.line_col(7.into()), LineCol { line: 1, col: 1.into() });
+            col: 0.into()
-    assert_eq!(index.line_col(8.into()), LineCol { line: 1, col: 2.into() });
+        }
-    assert_eq!(index.line_col(10.into()), LineCol { line: 1, col: 4.into() });
+    );
-    assert_eq!(index.line_col(11.into()), LineCol { line: 1, col: 5.into() });
+    assert_eq!(
-    assert_eq!(index.line_col(12.into()), LineCol { line: 1, col: 6.into() });
+        index.line_col(1.into()),
+        LineCol {
+            line: 0,
+            col: 1.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(5.into()),
+        LineCol {
+            line: 0,
+            col: 5.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(6.into()),
+        LineCol {
+            line: 1,
+            col: 0.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(7.into()),
+        LineCol {
+            line: 1,
+            col: 1.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(8.into()),
+        LineCol {
+            line: 1,
+            col: 2.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(10.into()),
+        LineCol {
+            line: 1,
+            col: 4.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(11.into()),
+        LineCol {
+            line: 1,
+            col: 5.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(12.into()),
+        LineCol {
+            line: 1,
+            col: 6.into()
+        }
+    );
    let text = "\nhello\nworld";
    let index = LineIndex::new(text);
-    assert_eq!(index.line_col(0.into()), LineCol { line: 0, col: 0.into() });
+    assert_eq!(
-    assert_eq!(index.line_col(1.into()), LineCol { line: 1, col: 0.into() });
+        index.line_col(0.into()),
-    assert_eq!(index.line_col(2.into()), LineCol { line: 1, col: 1.into() });
+        LineCol {
-    assert_eq!(index.line_col(6.into()), LineCol { line: 1, col: 5.into() });
+            line: 0,
-    assert_eq!(index.line_col(7.into()), LineCol { line: 2, col: 0.into() });
+            col: 0.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(1.into()),
+        LineCol {
+            line: 1,
+            col: 0.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(2.into()),
+        LineCol {
+            line: 1,
+            col: 1.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(6.into()),
+        LineCol {
+            line: 1,
+            col: 5.into()
+        }
+    );
+    assert_eq!(
+        index.line_col(7.into()),
+        LineCol {
+            line: 2,
+            col: 0.into()
+        }
+    );
 }
diff --git a/crates/ra_editor/src/scope/fn_scope.rs b/crates/ra_editor/src/scope/fn_scope.rs
index 99d698b60..9088e5a60 100644
--- a/crates/ra_editor/src/scope/fn_scope.rs
+++ b/crates/ra_editor/src/scope/fn_scope.rs
@@ -1,10 +1,11 @@
 use std::fmt;
 use rustc_hash::FxHashMap;
 use ra_syntax::{
-    SyntaxNodeRef, SyntaxNode, SmolStr, AstNode,
+    algo::generate,
-    ast::{self, NameOwner, LoopBodyOwner, ArgListOwner},
+    ast::{self, ArgListOwner, LoopBodyOwner, NameOwner},
-    algo::{generate}
+    AstNode, SmolStr, SyntaxNode, SyntaxNodeRef,
 };
 type ScopeId = usize;
@@ -19,11 +20,12 @@ pub struct FnScopes {
 impl FnScopes {
    pub fn new(fn_def: ast::FnDef) -> FnScopes {
        let mut scopes = FnScopes {
-            self_param: fn_def.param_list()
+            self_param: fn_def
+                .param_list()
                .and_then(|it| it.self_param())
                .map(|it| it.syntax().owned()),
            scopes: Vec::new(),
-            scope_for: FxHashMap::default()
+            scope_for: FxHashMap::default(),
        };
        let root = scopes.root_scope();
        scopes.add_params_bindings(root, fn_def.param_list());
@@ -35,27 +37,38 @@ impl FnScopes {
    pub fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
        &self.scopes[scope].entries
    }
-    pub fn scope_chain<'a>(&'a self, node: SyntaxNodeRef) -> impl Iterator<Item=ScopeId> + 'a {
+    pub fn scope_chain<'a>(&'a self, node: SyntaxNodeRef) -> impl Iterator<Item = ScopeId> + 'a {
-        generate(self.scope_for(node), move |&scope| self.scopes[scope].parent)
+        generate(self.scope_for(node), move |&scope| {
+            self.scopes[scope].parent
+        })
    }
    fn root_scope(&mut self) -> ScopeId {
        let res = self.scopes.len();
-        self.scopes.push(ScopeData { parent: None, entries: vec![] });
+        self.scopes.push(ScopeData {
+            parent: None,
+            entries: vec![],
+        });
        res
    }
    fn new_scope(&mut self, parent: ScopeId) -> ScopeId {
        let res = self.scopes.len();
-        self.scopes.push(ScopeData { parent: Some(parent), entries: vec![] });
+        self.scopes.push(ScopeData {
+            parent: Some(parent),
+            entries: vec![],
+        });
        res
    }
    fn add_bindings(&mut self, scope: ScopeId, pat: ast::Pat) {
-        let entries = pat.syntax().descendants()
+        let entries = pat
+            .syntax()
+            .descendants()
            .filter_map(ast::BindPat::cast)
            .filter_map(ScopeEntry::new);
        self.scopes[scope].entries.extend(entries);
    }
    fn add_params_bindings(&mut self, scope: ScopeId, params: Option<ast::ParamList>) {
-        params.into_iter()
+        params
+            .into_iter()
            .flat_map(|it| it.params())
            .filter_map(|it| it.pat())
            .for_each(|it| self.add_bindings(scope, it));
@@ -71,34 +84,33 @@ impl FnScopes {
 }
 pub struct ScopeEntry {
-    syntax: SyntaxNode
+    syntax: SyntaxNode,
 }
 impl ScopeEntry {
    fn new(pat: ast::BindPat) -> Option<ScopeEntry> {
        if pat.name().is_some() {
-            Some(ScopeEntry { syntax: pat.syntax().owned() })
+            Some(ScopeEntry {
+                syntax: pat.syntax().owned(),
+            })
        } else {
            None
        }
    }
    pub fn name(&self) -> SmolStr {
-        self.ast().name()
+        self.ast().name().unwrap().text()
-            .unwrap()
-            .text()
    }
    pub fn ast(&self) -> ast::BindPat {
-        ast::BindPat::cast(self.syntax.borrowed())
+        ast::BindPat::cast(self.syntax.borrowed()).unwrap()
-            .unwrap()
    }
 }
 impl fmt::Debug for ScopeEntry {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("ScopeEntry")
-         .field("name", &self.name())
+            .field("name", &self.name())
-         .field("syntax", &self.syntax)
+            .field("syntax", &self.syntax)
-         .finish()
+            .finish()
    }
 }
@@ -132,16 +144,16 @@ fn compute_block_scopes(block: ast::Block, scopes: &mut FnScopes, mut scope: Sco
 fn compute_expr_scopes(expr: ast::Expr, scopes: &mut FnScopes, scope: ScopeId) {
    match expr {
        ast::Expr::IfExpr(e) => {
-            let cond_scope = e.condition().and_then(|cond| {
+            let cond_scope = e
-                compute_cond_scopes(cond, scopes, scope)
+                .condition()
-            });
+                .and_then(|cond| compute_cond_scopes(cond, scopes, scope));
            if let Some(block) = e.then_branch() {
                compute_block_scopes(block, scopes, cond_scope.unwrap_or(scope));
            }
            if let Some(block) = e.else_branch() {
                compute_block_scopes(block, scopes, scope);
            }
-        },
+        }
        ast::Expr::BlockExpr(e) => {
            if let Some(block) = e.block() {
                compute_block_scopes(block, scopes, scope);
@@ -153,9 +165,9 @@ fn compute_expr_scopes(expr: ast::Expr, scopes: &mut FnScopes, scope: ScopeId) {
            }
        }
        ast::Expr::WhileExpr(e) => {
-            let cond_scope = e.condition().and_then(|cond| {
+            let cond_scope = e
-                compute_cond_scopes(cond, scopes, scope)
+                .condition()
-            });
+                .and_then(|cond| compute_cond_scopes(cond, scopes, scope));
            if let Some(block) = e.loop_body() {
                compute_block_scopes(block, scopes, cond_scope.unwrap_or(scope));
            }
@@ -201,25 +213,31 @@ fn compute_expr_scopes(expr: ast::Expr, scopes: &mut FnScopes, scope: ScopeId) {
                }
            }
        }
-        _ => {
+        _ => expr
-            expr.syntax().children()
+            .syntax()
-                .filter_map(ast::Expr::cast)
+            .children()
-                .for_each(|expr| compute_expr_scopes(expr, scopes, scope))
+            .filter_map(ast::Expr::cast)
-        }
+            .for_each(|expr| compute_expr_scopes(expr, scopes, scope)),
    };
    fn compute_call_scopes(
        receiver: Option<ast::Expr>,
        arg_list: Option<ast::ArgList>,
-        scopes: &mut FnScopes, scope: ScopeId,
+        scopes: &mut FnScopes,
+        scope: ScopeId,
    ) {
-        arg_list.into_iter()
+        arg_list
+            .into_iter()
            .flat_map(|it| it.args())
            .chain(receiver)
            .for_each(|expr| compute_expr_scopes(expr, scopes, scope));
    }
-    fn compute_cond_scopes(cond: ast::Condition, scopes: &mut FnScopes, scope: ScopeId) -> Option<ScopeId> {
+    fn compute_cond_scopes(
+        cond: ast::Condition,
+        scopes: &mut FnScopes,
+        scope: ScopeId,
+    ) -> Option<ScopeId> {
        if let Some(expr) = cond.expr() {
            compute_expr_scopes(expr, scopes, scope);
        }
@@ -236,14 +254,18 @@ fn compute_expr_scopes(expr: ast::Expr, scopes: &mut FnScopes, scope: ScopeId) {
 #[derive(Debug)]
 struct ScopeData {
    parent: Option<ScopeId>,
-    entries: Vec<ScopeEntry>
+    entries: Vec<ScopeEntry>,
 }
-pub fn resolve_local_name<'a>(name_ref: ast::NameRef, scopes: &'a FnScopes) -> Option<&'a ScopeEntry> {
+pub fn resolve_local_name<'a>(
+    name_ref: ast::NameRef,
+    scopes: &'a FnScopes,
+) -> Option<&'a ScopeEntry> {
    use rustc_hash::FxHashSet;
    let mut shadowed = FxHashSet::default();
-    let ret = scopes.scope_chain(name_ref.syntax())
+    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())
@@ -255,8 +277,8 @@ pub fn resolve_local_name<'a>(name_ref: ast::NameRef, scopes: &'a FnScopes) -> O
 #[cfg(test)]
 mod tests {
    use super::*;
-    use ra_syntax::File;
    use crate::{find_node_at_offset, test_utils::extract_offset};
+    use ra_syntax::File;
    fn do_check(code: &str, expected: &[&str]) {
        let (off, code) = extract_offset(code);
@@ -272,7 +294,8 @@ mod tests {
        let marker: ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
        let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
        let scopes = FnScopes::new(fn_def);
-        let actual = scopes.scope_chain(marker.syntax())
+        let actual = scopes
+            .scope_chain(marker.syntax())
            .flat_map(|scope| scopes.entries(scope))
            .map(|it| it.name())
            .collect::<Vec<_>>();
@@ -281,7 +304,8 @@ mod tests {
    #[test]
    fn test_lambda_scope() {
-        do_check(r"
+        do_check(
+            r"
            fn quux(foo: i32) {
                let f = |bar, baz: i32| {
                    <|>
@@ -293,7 +317,8 @@ mod tests {
    #[test]
    fn test_call_scope() {
-        do_check(r"
+        do_check(
+            r"
            fn quux() {
                f(|x| <|> );
            }",
@@ -303,7 +328,8 @@ mod tests {
    #[test]
    fn test_metod_call_scope() {
-        do_check(r"
+        do_check(
+            r"
            fn quux() {
                z.f(|x| <|> );
            }",
@@ -313,7 +339,8 @@ mod tests {
    #[test]
    fn test_loop_scope() {
-        do_check(r"
+        do_check(
+            r"
            fn quux() {
                loop {
                    let x = ();
@@ -326,7 +353,8 @@ mod tests {
    #[test]
    fn test_match() {
-        do_check(r"
+        do_check(
+            r"
            fn quux() {
                match () {
                    Some(x) => {
@@ -340,7 +368,8 @@ mod tests {