20 files changed, 401 insertions, 189 deletions

diff --git a/.travis.yml b/.travis.yml
index bddf1bebb..8d10a43f0 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -10,8 +10,6 @@ build: &rust_build
     script:
         - rustup component add rustfmt
         - rustup component add rust-src
-        - cargo gen-tests --verify
-        - cargo gen-syntax --verify
         - cargo test --no-run  # let's measure compile time separately
         - cargo test
     env:
diff --git a/crates/ra_hir/src/docs.rs b/crates/ra_hir/src/docs.rs
index b1b47af9e..5db72c08a 100644
--- a/crates/ra_hir/src/docs.rs
+++ b/crates/ra_hir/src/docs.rs
@@ -27,10 +27,5 @@ pub trait Docs {
 }
 
 pub(crate) fn docs_from_ast(node: &impl ast::DocCommentsOwner) -> Option<Documentation> {
-    let comments = node.doc_comment_text();
-    if comments.is_empty() {
-        None
-    } else {
-        Some(Documentation::new(&comments))
-    }
+    node.doc_comment_text().map(|it| Documentation::new(&it))
 }
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 29469af2c..60d997bbe 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -498,7 +498,13 @@ impl ExprCollector {
                     let then_branch = self.collect_block_opt(e.then_branch());
                     let else_branch = e
                         .else_branch()
-                        .map(|e| self.collect_block(e))
+                        .map(|b| match b {
+                            ast::ElseBranchFlavor::Block(it) => self.collect_block(it),
+                            ast::ElseBranchFlavor::IfExpr(elif) => {
+                                let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap();
+                                self.collect_expr(expr)
+                            }
+                        })
                         .unwrap_or_else(|| self.empty_block());
                     let placeholder_pat = self.pats.alloc(Pat::Missing);
                     let arms = vec![
@@ -521,7 +527,13 @@ impl ExprCollector {
                 } else {
                     let condition = self.collect_expr_opt(e.condition().and_then(|c| c.expr()));
                     let then_branch = self.collect_block_opt(e.then_branch());
-                    let else_branch = e.else_branch().map(|e| self.collect_block(e));
+                    let else_branch = e.else_branch().map(|b| match b {
+                        ast::ElseBranchFlavor::Block(it) => self.collect_block(it),
+                        ast::ElseBranchFlavor::IfExpr(elif) => {
+                            let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap();
+                            self.collect_expr(expr)
+                        }
+                    });
                     self.alloc_expr(
                         Expr::If {
                             condition,
diff --git a/crates/ra_hir/src/marks.rs b/crates/ra_hir/src/marks.rs
index 338ed0516..d704c3adb 100644
--- a/crates/ra_hir/src/marks.rs
+++ b/crates/ra_hir/src/marks.rs
@@ -1,4 +1,6 @@
 test_utils::marks!(
     name_res_works_for_broken_modules
     item_map_enum_importing
+    type_var_cycles_resolve_completely
+    type_var_cycles_resolve_as_possible
 );
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 179ebddee..31ea45706 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -29,6 +29,8 @@ use ra_arena::map::ArenaMap;
 use join_to_string::join;
 use rustc_hash::FxHashMap;
 
+use test_utils::tested_by;
+
 use crate::{
     Module, Function, Struct, StructField, Enum, EnumVariant, Path, Name, ImplBlock,
     FnSignature, FnScopes, ModuleDef, AdtDef,
@@ -862,14 +864,15 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     }
 
     fn resolve_all(mut self) -> InferenceResult {
+        let mut tv_stack = Vec::new();
         let mut expr_types = mem::replace(&mut self.type_of_expr, ArenaMap::default());
         for ty in expr_types.values_mut() {
-            let resolved = self.resolve_ty_completely(mem::replace(ty, Ty::Unknown));
+            let resolved = self.resolve_ty_completely(&mut tv_stack, mem::replace(ty, Ty::Unknown));
             *ty = resolved;
         }
         let mut pat_types = mem::replace(&mut self.type_of_pat, ArenaMap::default());
         for ty in pat_types.values_mut() {
-            let resolved = self.resolve_ty_completely(mem::replace(ty, Ty::Unknown));
+            let resolved = self.resolve_ty_completely(&mut tv_stack, mem::replace(ty, Ty::Unknown));
             *ty = resolved;
         }
         InferenceResult {
@@ -1014,13 +1017,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     /// by their known types. All types returned by the infer_* functions should
     /// be resolved as far as possible, i.e. contain no type variables with
     /// known type.
-    fn resolve_ty_as_possible(&mut self, ty: Ty) -> Ty {
+    fn resolve_ty_as_possible(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
         ty.fold(&mut |ty| match ty {
             Ty::Infer(tv) => {
                 let inner = tv.to_inner();
+                if tv_stack.contains(&inner) {
+                    tested_by!(type_var_cycles_resolve_as_possible);
+                    // recursive type
+                    return tv.fallback_value();
+                }
                 if let Some(known_ty) = self.var_unification_table.probe_value(inner).known() {
                     // known_ty may contain other variables that are known by now
-                    self.resolve_ty_as_possible(known_ty.clone())
+                    tv_stack.push(inner);
+                    let result = self.resolve_ty_as_possible(tv_stack, known_ty.clone());
+                    tv_stack.pop();
+                    result
                 } else {
                     ty
                 }
@@ -1049,13 +1060,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
     /// Resolves the type completely; type variables without known type are
     /// replaced by Ty::Unknown.
-    fn resolve_ty_completely(&mut self, ty: Ty) -> Ty {
+    fn resolve_ty_completely(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
         ty.fold(&mut |ty| match ty {
             Ty::Infer(tv) => {
                 let inner = tv.to_inner();
+                if tv_stack.contains(&inner) {
+                    tested_by!(type_var_cycles_resolve_completely);
+                    // recursive type
+                    return tv.fallback_value();
+                }
                 if let Some(known_ty) = self.var_unification_table.probe_value(inner).known() {
                     // known_ty may contain other variables that are known by now
-                    self.resolve_ty_completely(known_ty.clone())
+                    tv_stack.push(inner);
+                    let result = self.resolve_ty_completely(tv_stack, known_ty.clone());
+                    tv_stack.pop();
+                    result
                 } else {
                     tv.fallback_value()
                 }
@@ -1070,7 +1089,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             let name = path.as_ident().cloned().unwrap_or_else(Name::self_param);
             if let Some(scope_entry) = self.scopes.resolve_local_name(expr, name) {
                 let ty = self.type_of_pat.get(scope_entry.pat())?;
-                let ty = self.resolve_ty_as_possible(ty.clone());
+                let ty = self.resolve_ty_as_possible(&mut vec![], ty.clone());
                 return Some(ty);
             };
         };
@@ -1239,7 +1258,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         // use a new type variable if we got Ty::Unknown here
         let ty = self.insert_type_vars_shallow(ty);
         self.unify(&ty, expected);
-        let ty = self.resolve_ty_as_possible(ty);
+        let ty = self.resolve_ty_as_possible(&mut vec![], ty);
         self.write_pat_ty(pat, ty.clone());
         ty
     }
@@ -1538,7 +1557,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         // use a new type variable if we got Ty::Unknown here
         let ty = self.insert_type_vars_shallow(ty);
         self.unify(&ty, &expected.ty);
-        let ty = self.resolve_ty_as_possible(ty);
+        let ty = self.resolve_ty_as_possible(&mut vec![], ty);
         self.write_expr_ty(tgt_expr, ty.clone());
         ty
     }
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_in_elseif.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_in_elseif.snap
new file mode 100644
index 000000000..6a435e5cf
--- /dev/null
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_in_elseif.snap
@@ -0,0 +1,17 @@
+---
+created: "2019-01-26T21:36:52.714121185+00:00"
+creator: [email protected]
+expression: "&result"
+source: crates/ra_hir/src/ty/tests.rs
+---
+[35; 38) 'foo': Foo
+[45; 109) '{     ...   } }': ()
+[51; 107) 'if tru...     }': ()
+[54; 58) 'true': bool
+[59; 67) '{      }': ()
+[73; 107) 'if fal...     }': i32
+[76; 81) 'false': bool
+[82; 107) '{     ...     }': i32
+[92; 95) 'foo': Foo
+[92; 101) 'foo.field': i32
+
diff --git a/crates/ra_hir/src/ty/snapshots/tests__recursive_vars.snap b/crates/ra_hir/src/ty/snapshots/tests__recursive_vars.snap
new file mode 100644
index 000000000..c3227ff7e
--- /dev/null
+++ b/crates/ra_hir/src/ty/snapshots/tests__recursive_vars.snap
@@ -0,0 +1,14 @@
+---
+created: "2019-01-26T22:42:22.329980185+00:00"
+creator: [email protected]
+expression: "&result"
+source: crates/ra_hir/src/ty/tests.rs
+---
+[11; 48) '{     ...&y]; }': ()
+[21; 22) 'y': &[unknown]
+[25; 32) 'unknown': &[unknown]
+[38; 45) '[y, &y]': [&&[unknown]]
+[39; 40) 'y': &[unknown]
+[42; 44) '&y': &&[unknown]
+[43; 44) 'y': &[unknown]
+
diff --git a/crates/ra_hir/src/ty/snapshots/tests__recursive_vars_2.snap b/crates/ra_hir/src/ty/snapshots/tests__recursive_vars_2.snap
new file mode 100644
index 000000000..de124da5b
--- /dev/null
+++ b/crates/ra_hir/src/ty/snapshots/tests__recursive_vars_2.snap
@@ -0,0 +1,21 @@
+---
+created: "2019-01-26T22:42:22.331805845+00:00"
+creator: [email protected]
+expression: "&result"
+source: crates/ra_hir/src/ty/tests.rs
+---
+[11; 80) '{     ...x)]; }': ()
+[21; 22) 'x': &&[unknown]
+[25; 32) 'unknown': &&[unknown]
+[42; 43) 'y': &&[unknown]
+[46; 53) 'unknown': &&[unknown]
+[59; 77) '[(x, y..., &x)]': [(&&[unknown], &&[unknown])]
+[60; 66) '(x, y)': (&&[unknown], &&[unknown])
+[61; 62) 'x': &&[unknown]
+[64; 65) 'y': &&[unknown]
+[68; 76) '(&y, &x)': (&&&[unknown], &&&[unknown])
+[69; 71) '&y': &&&[unknown]
+[70; 71) 'y': &&[unknown]
+[73; 75) '&x': &&&[unknown]
+[74; 75) 'x': &&[unknown]
+
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index e0b0689f8..f74d6f5ea 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -3,6 +3,7 @@ use std::fmt::Write;
 
 use ra_db::{SourceDatabase, salsa::Database};
 use ra_syntax::ast::{self, AstNode};
+use test_utils::covers;
 
 use crate::{
     source_binder,
@@ -285,6 +286,23 @@ fn test() {
 }
 
 #[test]
+fn infer_in_elseif() {
+    check_inference(
+        "infer_in_elseif",
+        r#"
+struct Foo { field: i32 }
+fn main(foo: Foo) {
+    if true {
+
+    } else if false {
+        foo.field
+    }
+}
+"#,
+    )
+}
+
+#[test]
 fn infer_inherent_method() {
     check_inference(
         "infer_inherent_method",
@@ -545,6 +563,37 @@ fn quux() {
     );
 }
 
+#[test]
+fn recursive_vars() {
+    covers!(type_var_cycles_resolve_completely);
+    covers!(type_var_cycles_resolve_as_possible);
+    check_inference(
+        "recursive_vars",
+        r#"
+fn test() {
+    let y = unknown;
+    [y, &y];
+}
+"#,
+    );
+}
+
+#[test]
+fn recursive_vars_2() {
+    covers!(type_var_cycles_resolve_completely);
+    covers!(type_var_cycles_resolve_as_possible);
+    check_inference(
+        "recursive_vars_2",
+        r#"
+fn test() {
+    let x = unknown;
+    let y = unknown;
+    [(x, y), (&y, &x)];
+}
+"#,
+    );
+}
+
 fn infer(content: &str) -> String {
     let (db, _, file_id) = MockDatabase::with_single_file(content);
     let source_file = db.parse(file_id);
diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index 3267fff96..ee1e13799 100644
--- a/crates/ra_ide_api/src/call_info.rs
+++ b/crates/ra_ide_api/src/call_info.rs
@@ -1,3 +1,4 @@
+use test_utils::tested_by;
 use ra_db::SourceDatabase;
 use ra_syntax::{
     AstNode, SyntaxNode, TextUnit, TextRange,
@@ -41,7 +42,12 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
         // where offset is in that list (or beyond).
         // Revisit this after we get documentation comments in.
         if let Some(ref arg_list) = calling_node.arg_list() {
-            let start = arg_list.syntax().range().start();
+            let arg_list_range = arg_list.syntax().range();
+            if !arg_list_range.contains_inclusive(position.offset) {
+                tested_by!(call_info_bad_offset);
+                return None;
+            }
+            let start = arg_list_range.start();
 
             let range_search = TextRange::from_to(start, position.offset);
             let mut commas: usize = arg_list
@@ -120,8 +126,7 @@ impl CallInfo {
         };
 
         let mut doc = None;
-        let docs = node.doc_comment_text();
-        if !docs.is_empty() {
+        if let Some(docs) = node.doc_comment_text() {
             // Massage markdown
             let mut processed_lines = Vec::new();
             let mut in_code_block = false;
@@ -172,10 +177,12 @@ fn param_list(node: &ast::FnDef) -> Vec<String> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use test_utils::covers;
 
     use crate::mock_analysis::single_file_with_position;
 
+    use super::*;
+
     fn call_info(text: &str) -> CallInfo {
         let (analysis, position) = single_file_with_position(text);
         analysis.call_info(position).unwrap().unwrap()
@@ -417,4 +424,14 @@ By default this method stops actor's `Context`."#
         );
     }
 
+    #[test]
+    fn call_info_bad_offset() {
+        covers!(call_info_bad_offset);
+        let (analysis, position) = single_file_with_position(
+            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+               fn bar() { foo <|> (3, ); }"#,
+        );
+        let call_info = analysis.call_info(position).unwrap();
+        assert!(call_info.is_none());
+    }
 }
diff --git a/crates/ra_ide_api/src/hover.rs b/crates/ra_ide_api/src/hover.rs
index ff9ae2d9c..f993a461c 100644
--- a/crates/ra_ide_api/src/hover.rs
+++ b/crates/ra_ide_api/src/hover.rs
@@ -100,12 +100,7 @@ impl NavigationTarget {
     fn docs(&self, db: &RootDatabase) -> Option<String> {
         let node = self.node(db)?;
         fn doc_comments<N: ast::DocCommentsOwner>(node: &N) -> Option<String> {
-            let comments = node.doc_comment_text();
-            if comments.is_empty() {
-                None
-            } else {
-                Some(comments)
-            }
+            node.doc_comment_text()
         }
 
         visitor()
diff --git a/crates/ra_ide_api/src/marks.rs b/crates/ra_ide_api/src/marks.rs
index e33bf6c91..21ce7289d 100644
--- a/crates/ra_ide_api/src/marks.rs
+++ b/crates/ra_ide_api/src/marks.rs
@@ -2,4 +2,5 @@ test_utils::marks!(
     inserts_parens_for_function_calls
     goto_definition_works_for_methods
     goto_definition_works_for_fields
+    call_info_bad_offset
 );
diff --git a/crates/ra_ide_api_light/src/assists/replace_if_let_with_match.rs b/crates/ra_ide_api_light/src/assists/replace_if_let_with_match.rs
index d64c34d54..71880b919 100644
--- a/crates/ra_ide_api_light/src/assists/replace_if_let_with_match.rs
+++ b/crates/ra_ide_api_light/src/assists/replace_if_let_with_match.rs
@@ -11,7 +11,10 @@ pub fn replace_if_let_with_match(ctx: AssistCtx) -> Option<Assist> {
     let pat = cond.pat()?;
     let expr = cond.expr()?;
     let then_block = if_expr.then_branch()?;
-    let else_block = if_expr.else_branch()?;
+    let else_block = match if_expr.else_branch()? {
+        ast::ElseBranchFlavor::Block(it) => it,
+        ast::ElseBranchFlavor::IfExpr(_) => return None,
+    };
 
     ctx.build("replace with match", |edit| {
         let match_expr = build_match_expr(expr, pat, then_block, else_block);
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 8ea9edc84..ace3da020 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -520,21 +520,33 @@ pub fn handle_formatting(
     let end_position = TextUnit::of_str(&file).conv_with(&file_line_index);
 
     use std::process;
-    let mut rustfmt = process::Command::new("rustfmt")
+    let mut rustfmt = process::Command::new("rustfmt");
+    rustfmt
         .stdin(process::Stdio::piped())
-        .stdout(process::Stdio::piped())
-        .spawn()?;
+        .stdout(process::Stdio::piped());
+
+    if let Ok(path) = params.text_document.uri.to_file_path() {
+        if let Some(parent) = path.parent() {
+            rustfmt.current_dir(parent);
+        }
+    }
+    let mut rustfmt = rustfmt.spawn()?;
 
     rustfmt.stdin.as_mut().unwrap().write_all(file.as_bytes())?;
 
     let output = rustfmt.wait_with_output()?;
     let captured_stdout = String::from_utf8(output.stdout)?;
     if !output.status.success() {
-        failure::bail!(
-            "rustfmt exited with error code {}: {}.",
-            output.status,
-            captured_stdout,
-        );
+        return Err(LspError::new(
+            -32900,
+            format!(
+                r#"rustfmt exited with:
+            Status: {}
+            stdout: {}"#,
+                output.status, captured_stdout,
+            ),
+        )
+        .into());
     }
 
     Ok(Some(vec![TextEdit {
diff --git a/crates/ra_lsp_server/src/project_model/cargo_workspace.rs b/crates/ra_lsp_server/src/project_model/cargo_workspace.rs
index 75ae78bca..8cf99d586 100644
--- a/crates/ra_lsp_server/src/project_model/cargo_workspace.rs
+++ b/crates/ra_lsp_server/src/project_model/cargo_workspace.rs
@@ -117,9 +117,13 @@ impl Target {
 
 impl CargoWorkspace {
     pub fn from_cargo_metadata(cargo_toml: &Path) -> Result<CargoWorkspace> {
-        let meta = MetadataCommand::new()
-            .manifest_path(cargo_toml)
-            .features(CargoOpt::AllFeatures)
+        let mut meta = MetadataCommand::new();
+        meta.manifest_path(cargo_toml)
+            .features(CargoOpt::AllFeatures);
+        if let Some(parent) = cargo_toml.parent() {
+            meta.current_dir(parent);
+        }
+        let meta = meta
             .exec()
             .map_err(|e| format_err!("cargo metadata failed: {}", e))?;
         let mut pkg_by_id = FxHashMap::default();
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 00c60ebf3..3d22a88f3 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -115,21 +115,38 @@ pub trait DocCommentsOwner: AstNode {
     }
 
     /// Returns the textual content of a doc comment block as a single string.
-    /// That is, strips leading `///` and joins lines
-    fn doc_comment_text(&self) -> std::string::String {
-        self.doc_comments()
+    /// That is, strips leading `///` (+ optional 1 character of whitespace)
+    /// and joins lines.
+    fn doc_comment_text(&self) -> Option<std::string::String> {
+        let docs = self
+            .doc_comments()
             .filter(|comment| comment.is_doc_comment())
             .map(|comment| {
-                let prefix = comment.prefix();
-                let trimmed = comment
-                    .text()
-                    .as_str()
-                    .trim()
-                    .trim_start_matches(prefix)
-                    .trim_start();
-                trimmed.to_owned()
+                let prefix_len = comment.prefix().len();
+
+                let line = comment.text().as_str();
+
+                // Determine if the prefix or prefix + 1 char is stripped
+                let pos = if line
+                    .chars()
+                    .nth(prefix_len)
+                    .map(|c| c.is_whitespace())
+                    .unwrap_or(false)
+                {
+                    prefix_len + 1
+                } else {
+                    prefix_len
+                };
+
+                line[pos..].to_owned()
             })
-            .join("\n")
+            .join("\n");
+
+        if docs.is_empty() {
+            None
+        } else {
+            Some(docs)
+        }
     }
 }
 
@@ -285,13 +302,27 @@ impl LetStmt {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ElseBranchFlavor<'a> {
+    Block(&'a Block),
+    IfExpr(&'a IfExpr),
+}
+
 impl IfExpr {
     pub fn then_branch(&self) -> Option<&Block> {
         self.blocks().nth(0)
     }
-    pub fn else_branch(&self) -> Option<&Block> {
-        self.blocks().nth(1)
+    pub fn else_branch(&self) -> Option<ElseBranchFlavor> {
+        let res = match self.blocks().nth(1) {
+            Some(block) => ElseBranchFlavor::Block(block),
+            None => {
+                let elif: &IfExpr = child_opt(self)?;
+                ElseBranchFlavor::IfExpr(elif)
+            }
+        };
+        Some(res)
     }
+
     fn blocks(&self) -> AstChildren<Block> {
         children(self)
     }
@@ -690,6 +721,18 @@ impl BindPat {
 }
 
 #[test]
+fn test_doc_comment_none() {
+    let file = SourceFile::parse(
+        r#"
+        // non-doc
+        mod foo {}
+        "#,
+    );
+    let module = file.syntax().descendants().find_map(Module::cast).unwrap();
+    assert!(module.doc_comment_text().is_none());
+}
+
+#[test]
 fn test_doc_comment_of_items() {
     let file = SourceFile::parse(
         r#"
@@ -699,5 +742,25 @@ fn test_doc_comment_of_items() {
         "#,
     );
     let module = file.syntax().descendants().find_map(Module::cast).unwrap();
-    assert_eq!("doc", module.doc_comment_text());
+    assert_eq!("doc", module.doc_comment_text().unwrap());
+}
+
+#[test]
+fn test_doc_comment_preserves_indents() {
+    let file = SourceFile::parse(
+        r#"
+        /// doc1
+        /// ```
+        /// fn foo() {
+        ///     // ...
+        /// }
+        /// ```
+        mod foo {}
+        "#,
+    );
+    let module = file.syntax().descendants().find_map(Module::cast).unwrap();
+    assert_eq!(
+        "doc1\n```\nfn foo() {\n    // ...\n}\n```",
+        module.doc_comment_text().unwrap()
+    );
 }
diff --git a/crates/tools/src/bin/pre-commit.rs b/crates/tools/src/bin/pre-commit.rs
index bae3b26d3..e00bd0d3d 100644
--- a/crates/tools/src/bin/pre-commit.rs
+++ b/crates/tools/src/bin/pre-commit.rs
@@ -1,10 +1,9 @@
-use std::{
-    process::{Command},
-};
+use std::process::Command;
 
-use tools::{Result, run_rustfmt, run, project_root};
 use failure::bail;
 
+use tools::{Result, run_rustfmt, run, project_root};
+
 fn main() -> tools::Result<()> {
     run_rustfmt(tools::Overwrite)?;
     update_staged()
diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs
index d404db214..311bcb4d8 100644
--- a/crates/tools/src/lib.rs
+++ b/crates/tools/src/lib.rs
@@ -1,7 +1,8 @@
 use std::{
+    fs,
+    collections::HashMap,
     path::{Path, PathBuf},
     process::{Command, Stdio},
-    fs::copy,
     io::{Error, ErrorKind}
 };
 
@@ -13,6 +14,10 @@ pub use teraron::{Mode, Overwrite, Verify};
 pub type Result<T> = std::result::Result<T, failure::Error>;
 
 pub const GRAMMAR: &str = "crates/ra_syntax/src/grammar.ron";
+const GRAMMAR_DIR: &str = "crates/ra_syntax/src/grammar";
+const OK_INLINE_TESTS_DIR: &str = "crates/ra_syntax/tests/data/parser/inline/ok";
+const ERR_INLINE_TESTS_DIR: &str = "crates/ra_syntax/tests/data/parser/inline/err";
+
 pub const SYNTAX_KINDS: &str = "crates/ra_syntax/src/syntax_kinds/generated.rs.tera";
 pub const AST: &str = "crates/ra_syntax/src/ast/generated.rs.tera";
 const TOOLCHAIN: &str = "stable";
@@ -130,9 +135,9 @@ pub fn install_format_hook() -> Result<()> {
     if !result_path.exists() {
         run("cargo build --package tools --bin pre-commit", ".")?;
         if cfg!(windows) {
-            copy("./target/debug/pre-commit.exe", result_path)?;
+            fs::copy("./target/debug/pre-commit.exe", result_path)?;
         } else {
-            copy("./target/debug/pre-commit", result_path)?;
+            fs::copy("./target/debug/pre-commit", result_path)?;
         }
     } else {
         return Err(Error::new(ErrorKind::AlreadyExists, "Git hook already created").into());
@@ -156,3 +161,98 @@ pub fn run_fuzzer() -> Result<()> {
         "./crates/ra_syntax",
     )
 }
+
+pub fn gen_tests(mode: Mode) -> Result<()> {
+    let tests = tests_from_dir(&project_root().join(Path::new(GRAMMAR_DIR)))?;
+    fn install_tests(tests: &HashMap<String, Test>, into: &str, mode: Mode) -> Result<()> {
+        let tests_dir = project_root().join(into);
+        if !tests_dir.is_dir() {
+            fs::create_dir_all(&tests_dir)?;
+        }
+        // ok is never actually read, but it needs to be specified to create a Test in existing_tests
+        let existing = existing_tests(&tests_dir, true)?;
+        for t in existing.keys().filter(|&t| !tests.contains_key(t)) {
+            panic!("Test is deleted: {}", t);
+        }
+
+        let mut new_idx = existing.len() + 1;
+        for (name, test) in tests {
+            let path = match existing.get(name) {
+                Some((path, _test)) => path.clone(),
+                None => {
+                    let file_name = format!("{:04}_{}.rs", new_idx, name);
+                    new_idx += 1;
+                    tests_dir.join(file_name)
+                }
+            };
+            teraron::update(&path, &test.text, mode)?;
+        }
+        Ok(())
+    }
+    install_tests(&tests.ok, OK_INLINE_TESTS_DIR, mode)?;
+    install_tests(&tests.err, ERR_INLINE_TESTS_DIR, mode)
+}
+
+#[derive(Default, Debug)]
+struct Tests {
+    pub ok: HashMap<String, Test>,
+    pub err: HashMap<String, Test>,
+}
+
+fn tests_from_dir(dir: &Path) -> Result<Tests> {
+    let mut res = Tests::default();
+    for entry in ::walkdir::WalkDir::new(dir) {
+        let entry = entry.unwrap();
+        if !entry.file_type().is_file() {
+            continue;
+        }
+        if entry.path().extension().unwrap_or_default() != "rs" {
+            continue;
+        }
+        process_file(&mut res, entry.path())?;
+    }
+    let grammar_rs = dir.parent().unwrap().join("grammar.rs");
+    process_file(&mut res, &grammar_rs)?;
+    return Ok(res);
+    fn process_file(res: &mut Tests, path: &Path) -> Result<()> {
+        let text = fs::read_to_string(path)?;
+
+        for (_, test) in collect_tests(&text) {
+            if test.ok {
+                if let Some(old_test) = res.ok.insert(test.name.clone(), test) {
+                    bail!("Duplicate test: {}", old_test.name)
+                }
+            } else {
+                if let Some(old_test) = res.err.insert(test.name.clone(), test) {
+                    bail!("Duplicate test: {}", old_test.name)
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+fn existing_tests(dir: &Path, ok: bool) -> Result<HashMap<String, (PathBuf, Test)>> {
+    let mut res = HashMap::new();
+    for file in fs::read_dir(dir)? {
+        let file = file?;
+        let path = file.path();
+        if path.extension().unwrap_or_default() != "rs" {
+            continue;
+        }
+        let name = {
+            let file_name = path.file_name().unwrap().to_str().unwrap();
+            file_name[5..file_name.len() - 3].to_string()
+        };
+        let text = fs::read_to_string(&path)?;
+        let test = Test {
+            name: name.clone(),
+            text,
+            ok,
+        };
+        if let Some(old) = res.insert(name, (path, test)) {
+            println!("Duplicate test: {:?}", old);
+        }
+    }
+    Ok(res)
+}
diff --git a/crates/tools/src/main.rs b/crates/tools/src/main.rs
index d6eabce6c..c3e293911 100644
--- a/crates/tools/src/main.rs
+++ b/crates/tools/src/main.rs
@@ -1,30 +1,13 @@
-use std::{
-    collections::HashMap,
-    fs,
-    path::{Path, PathBuf},
-};
-
-use clap::{App, Arg, SubCommand};
-use failure::bail;
+use clap::{App, SubCommand};
 
 use tools::{
-    collect_tests, generate,install_format_hook, run, run_rustfmt,
-    Mode, Overwrite, Result, Test, Verify, project_root, run_fuzzer
+    generate, gen_tests, install_format_hook, run, run_rustfmt,
+    Overwrite, Result, run_fuzzer,
 };
 
-const GRAMMAR_DIR: &str = "crates/ra_syntax/src/grammar";
-const OK_INLINE_TESTS_DIR: &str = "crates/ra_syntax/tests/data/parser/inline/ok";
-const ERR_INLINE_TESTS_DIR: &str = "crates/ra_syntax/tests/data/parser/inline/err";
-
 fn main() -> Result<()> {
     let matches = App::new("tasks")
         .setting(clap::AppSettings::SubcommandRequiredElseHelp)
-        .arg(
-            Arg::with_name("verify")
-                .long("--verify")
-                .help("Verify that generated code is up-to-date")
-                .global(true),
-        )
         .subcommand(SubCommand::with_name("gen-syntax"))
         .subcommand(SubCommand::with_name("gen-tests"))
         .subcommand(SubCommand::with_name("install-code"))
@@ -32,19 +15,14 @@ fn main() -> Result<()> {
         .subcommand(SubCommand::with_name("format-hook"))
         .subcommand(SubCommand::with_name("fuzz-tests"))
         .get_matches();
-    let mode = if matches.is_present("verify") {
-        Verify
-    } else {
-        Overwrite
-    };
     match matches
         .subcommand_name()
         .expect("Subcommand must be specified")
     {
         "install-code" => install_code_extension()?,
-        "gen-tests" => gen_tests(mode)?,
+        "gen-tests" => gen_tests(Overwrite)?,
         "gen-syntax" => generate(Overwrite)?,
-        "format" => run_rustfmt(mode)?,
+        "format" => run_rustfmt(Overwrite)?,
         "format-hook" => install_format_hook()?,
         "fuzz-tests" => run_fuzzer()?,
         _ => unreachable!(),
@@ -52,101 +30,6 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn gen_tests(mode: Mode) -> Result<()> {
-    let tests = tests_from_dir(Path::new(GRAMMAR_DIR))?;
-    fn install_tests(tests: &HashMap<String, Test>, into: &str, mode: Mode) -> Result<()> {
-        let tests_dir = project_root().join(into);
-        if !tests_dir.is_dir() {
-            fs::create_dir_all(&tests_dir)?;
-        }
-        // ok is never actually read, but it needs to be specified to create a Test in existing_tests
-        let existing = existing_tests(&tests_dir, true)?;
-        for t in existing.keys().filter(|&t| !tests.contains_key(t)) {
-            panic!("Test is deleted: {}", t);
-        }
-
-        let mut new_idx = existing.len() + 1;
-        for (name, test) in tests {
-            let path = match existing.get(name) {
-                Some((path, _test)) => path.clone(),
-                None => {
-                    let file_name = format!("{:04}_{}.rs", new_idx, name);
-                    new_idx += 1;
-                    tests_dir.join(file_name)
-                }
-            };
-            teraron::update(&path, &test.text, mode)?;
-        }
-        Ok(())
-    }
-    install_tests(&tests.ok, OK_INLINE_TESTS_DIR, mode)?;
-    install_tests(&tests.err, ERR_INLINE_TESTS_DIR, mode)
-}
-
-#[derive(Default, Debug)]
-struct Tests {
-    pub ok: HashMap<String, Test>,
-    pub err: HashMap<String, Test>,
-}
-
-fn tests_from_dir(dir: &Path) -> Result<Tests> {
-    let mut res = Tests::default();
-    for entry in ::walkdir::WalkDir::new(dir) {
-        let entry = entry.unwrap();
-        if !entry.file_type().is_file() {
-            continue;
-        }
-        if entry.path().extension().unwrap_or_default() != "rs" {
-            continue;
-        }
-        process_file(&mut res, entry.path())?;
-    }
-    let grammar_rs = dir.parent().unwrap().join("grammar.rs");
-    process_file(&mut res, &grammar_rs)?;
-    return Ok(res);
-    fn process_file(res: &mut Tests, path: &Path) -> Result<()> {
-        let text = fs::read_to_string(path)?;
-
-        for (_, test) in collect_tests(&text) {
-            if test.ok {
-                if let Some(old_test) = res.ok.insert(test.name.clone(), test) {
-                    bail!("Duplicate test: {}", old_test.name)
-                }
-            } else {
-                if let Some(old_test) = res.err.insert(test.name.clone(), test) {
-                    bail!("Duplicate test: {}", old_test.name)
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
-fn existing_tests(dir: &Path, ok: bool) -> Result<HashMap<String, (PathBuf, Test)>> {
-    let mut res = HashMap::new();
-    for file in fs::read_dir(dir)? {
-        let file = file?;
-        let path = file.path();
-        if path.extension().unwrap_or_default() != "rs" {
-            continue;
-        }
-        let name = {
-            let file_name = path.file_name().unwrap().to_str().unwrap();
-            file_name[5..file_name.len() - 3].to_string()
-        };
-        let text = fs::read_to_string(&path)?;
-        let test = Test {
-            name: name.clone(),
-            text,
-            ok,
-        };
-        if let Some(old) = res.insert(name, (path, test)) {
-            println!("Duplicate test: {:?}", old);
-        }
-    }
-    Ok(res)
-}
-
 fn install_code_extension() -> Result<()> {
     run("cargo install --path crates/ra_lsp_server --force", ".")?;
     if cfg!(windows) {
diff --git a/crates/tools/tests/cli.rs b/crates/tools/tests/cli.rs
index 2d238d9ea..2ee4b5223 100644
--- a/crates/tools/tests/cli.rs
+++ b/crates/tools/tests/cli.rs
@@ -1,15 +1,23 @@
-extern crate tools;
-
-use tools::{generate, run_rustfmt, Verify};
+use tools::{generate, gen_tests, run_rustfmt, Verify};
 
 #[test]
-fn verify_template_generation() {
+fn generated_grammar_is_fresh() {
     if let Err(error) = generate(Verify) {
         panic!("{}. Please update it by running `cargo gen-syntax`", error);
     }
 }
 
 #[test]
+fn generated_tests_are_fresh() {
+    if let Err(error) = gen_tests(Verify) {
+        panic!(
+            "{}. Please update tests by running `cargo gen-tests`",
+            error
+        );
+    }
+}
+
+#[test]
 fn check_code_formatting() {
     if let Err(error) = run_rustfmt(Verify) {
         panic!(