26 files changed, 202 insertions, 61 deletions

diff --git a/crates/ra_analysis/src/completion/mod.rs b/crates/ra_analysis/src/completion.rs
index 0f154112a..0f154112a 100644
--- a/crates/ra_analysis/src/completion/mod.rs
+++ b/crates/ra_analysis/src/completion.rs
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 975afc145..03d17de0d 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -27,6 +27,7 @@ use crate::{
     symbol_index::{SymbolIndex, SymbolsDatabase},
     AnalysisChange, Cancelable, CrateId, Diagnostic, FileId,
     FileSystemEdit, FilePosition, Query, SourceChange, SourceFileNodeEdit,
+    ReferenceResolution,
 };
 
 #[derive(Debug, Default)]
@@ -144,7 +145,7 @@ impl AnalysisImpl {
         } else {
             let files = &self.db.source_root(WORKSPACE).files;
 
-            /// Need to wrap Snapshot to provide `Clon` impl for `map_with`
+            /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
             struct Snap(salsa::Snapshot<db::RootDatabase>);
             impl Clone for Snap {
                 fn clone(&self) -> Snap {
@@ -164,7 +165,7 @@ impl AnalysisImpl {
             .sweep(salsa::SweepStrategy::default().discard_values());
         Ok(query.search(&buf))
     }
-    /// This return `Vec`: a module may be included from several places. We
+    /// This returns `Vec` because a module may be included from several places. We
     /// don't handle this case yet though, so the Vec has length at most one.
     pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         let descr = match source_binder::module_from_position(&*self.db, position)? {
@@ -206,10 +207,11 @@ impl AnalysisImpl {
     pub fn approximately_resolve_symbol(
         &self,
         position: FilePosition,
-    ) -> Cancelable<Vec<(FileId, FileSymbol)>> {
+    ) -> Cancelable<Option<ReferenceResolution>> {
         let file = self.db.source_file(position.file_id);
         let syntax = file.syntax();
         if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
+            let mut rr = ReferenceResolution::new(name_ref.syntax().range());
             if let Some(fn_descr) = source_binder::function_from_child_node(
                 &*self.db,
                 position.file_id,
@@ -218,22 +220,25 @@ impl AnalysisImpl {
                 let scope = fn_descr.scope(&*self.db);
                 // First try to resolve the symbol locally
                 if let Some(entry) = scope.resolve_local_name(name_ref) {
-                    let mut vec = vec![];
-                    vec.push((
+                    rr.add_resolution(
                         position.file_id,
                         FileSymbol {
                             name: entry.name().clone(),
                             node_range: entry.ptr().range(),
                             kind: NAME,
                         },
-                    ));
-                    return Ok(vec);
+                    );
+                    return Ok(Some(rr));
                 };
             }
             // If that fails try the index based approach.
-            return self.index_resolve(name_ref);
+            for (file_id, symbol) in self.index_resolve(name_ref)? {
+                rr.add_resolution(file_id, symbol);
+            }
+            return Ok(Some(rr));
         }
         if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
+            let mut rr = ReferenceResolution::new(name.syntax().range());
             if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
                 if module.has_semi() {
                     let parent_module =
@@ -248,7 +253,8 @@ impl AnalysisImpl {
                                     node_range: TextRange::offset_len(0.into(), 0.into()),
                                     kind: MODULE,
                                 };
-                                return Ok(vec![(file_id, symbol)]);
+                                rr.add_resolution(file_id, symbol);
+                                return Ok(Some(rr));
                             }
                         }
                         _ => (),
@@ -256,7 +262,7 @@ impl AnalysisImpl {
                 }
             }
         }
-        Ok(vec![])
+        Ok(None)
     }
 
     pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {
@@ -318,6 +324,19 @@ impl AnalysisImpl {
 
         Ok(symbol.docs(&file))
     }
+    pub fn doc_text_for(&self, file_id: FileId, symbol: FileSymbol) -> Cancelable<Option<String>> {
+        let file = self.db.source_file(file_id);
+        let result = match (symbol.description(&file), symbol.docs(&file)) {
+            (Some(desc), Some(docs)) => {
+                Some("```rust\n".to_string() + &*desc + "\n```\n\n" + &*docs)
+            }
+            (Some(desc), None) => Some("```rust\n".to_string() + &*desc + "\n```"),
+            (None, Some(docs)) => Some(docs),
+            _ => None,
+        };
+
+        Ok(result)
+    }
 
     pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
         let syntax = self.db.source_file(file_id);
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 4b8b10816..eaf24cb36 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -178,6 +178,30 @@ impl Query {
     }
 }
 
+/// Result of "goto def" query.
+#[derive(Debug)]
+pub struct ReferenceResolution {
+    /// The range of the reference itself. Client does not know what constitutes
+    /// a reference, it handles us only the offset. It's helpful to tell the
+    /// client where the reference was.
+    pub reference_range: TextRange,
+    /// What this reference resolves to.
+    pub resolves_to: Vec<(FileId, FileSymbol)>,
+}
+
+impl ReferenceResolution {
+    fn new(reference_range: TextRange) -> ReferenceResolution {
+        ReferenceResolution {
+            reference_range,
+            resolves_to: Vec::new(),
+        }
+    }
+
+    fn add_resolution(&mut self, file_id: FileId, symbol: FileSymbol) {
+        self.resolves_to.push((file_id, symbol))
+    }
+}
+
 /// Analysis is a snapshot of a world state at a moment in time. It is the main
 /// entry point for asking semantic information about the world. When the world
 /// state is advanced using `AnalysisHost::apply_change` method, all existing
@@ -236,7 +260,7 @@ impl Analysis {
     pub fn approximately_resolve_symbol(
         &self,
         position: FilePosition,
-    ) -> Cancelable<Vec<(FileId, FileSymbol)>> {
+    ) -> Cancelable<Option<ReferenceResolution>> {
         self.imp.approximately_resolve_symbol(position)
     }
     pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {
@@ -249,6 +273,9 @@ impl Analysis {
     ) -> Cancelable<Option<String>> {
         self.imp.doc_comment_for(file_id, symbol)
     }
+    pub fn doc_text_for(&self, file_id: FileId, symbol: FileSymbol) -> Cancelable<Option<String>> {
+        self.imp.doc_text_for(file_id, symbol)
+    }
     pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         self.imp.parent_module(position)
     }
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
index 4ce2c5c85..889b568b9 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/tests.rs
@@ -21,9 +21,12 @@ fn approximate_resolve_works_in_items() {
     ",
     );
 
-    let symbols = analysis.approximately_resolve_symbol(pos).unwrap();
+    let symbols = analysis.approximately_resolve_symbol(pos).unwrap().unwrap();
     assert_eq_dbg(
-        r#"[(FileId(1), FileSymbol { name: "Foo", node_range: [0; 11), kind: STRUCT_DEF })]"#,
+        r#"ReferenceResolution {
+            reference_range: [23; 26),
+            resolves_to: [(FileId(1), FileSymbol { name: "Foo", node_range: [0; 11), kind: STRUCT_DEF })]
+        }"#,
         &symbols,
     );
 }
@@ -39,9 +42,12 @@ fn test_resolve_module() {
     ",
     );
 
-    let symbols = analysis.approximately_resolve_symbol(pos).unwrap();
+    let symbols = analysis.approximately_resolve_symbol(pos).unwrap().unwrap();
     assert_eq_dbg(
-        r#"[(FileId(2), FileSymbol { name: "foo", node_range: [0; 0), kind: MODULE })]"#,
+        r#"ReferenceResolution {
+            reference_range: [4; 7),
+            resolves_to: [(FileId(2), FileSymbol { name: "foo", node_range: [0; 0), kind: MODULE })]
+        }"#,
         &symbols,
     );
 
@@ -54,9 +60,12 @@ fn test_resolve_module() {
     ",
     );
 
-    let symbols = analysis.approximately_resolve_symbol(pos).unwrap();
+    let symbols = analysis.approximately_resolve_symbol(pos).unwrap().unwrap();
     assert_eq_dbg(
-        r#"[(FileId(2), FileSymbol { name: "foo", node_range: [0; 0), kind: MODULE })]"#,
+        r#"ReferenceResolution {
+            reference_range: [4; 7),
+            resolves_to: [(FileId(2), FileSymbol { name: "foo", node_range: [0; 0), kind: MODULE })]
+        }"#,
         &symbols,
     );
 }
diff --git a/crates/ra_editor/src/extend_selection.rs b/crates/ra_editor/src/extend_selection.rs
index 8f11d5364..a2aa02149 100644
--- a/crates/ra_editor/src/extend_selection.rs
+++ b/crates/ra_editor/src/extend_selection.rs
@@ -48,13 +48,18 @@ fn extend_single_word_in_comment(leaf: SyntaxNodeRef, offset: TextUnit) -> Optio
     let cursor_position: u32 = (offset - leaf.range().start()).into();
 
     let (before, after) = text.split_at(cursor_position as usize);
-    let start_idx = before.rfind(char::is_whitespace)? as u32;
-    let end_idx = after.find(char::is_whitespace)? as u32;
+    let start_idx = before.rfind(char::is_whitespace).unwrap_or(0) as u32;
+    let end_idx = after.find(char::is_whitespace).unwrap_or(after.len()) as u32;
 
     let from: TextUnit = (start_idx + 1).into();
     let to: TextUnit = (cursor_position + end_idx).into();
 
-    Some(TextRange::from_to(from, to) + leaf.range().start())
+    let range = TextRange::from_to(from, to);
+    if range.is_empty() {
+        None
+    } else {
+        Some(range + leaf.range().start())
+    }
 }
 
 fn extend_ws(root: SyntaxNodeRef, ws: SyntaxNodeRef, offset: TextUnit) -> TextRange {
@@ -179,7 +184,21 @@ fn bar(){}
 
 // fn foo(){}
     "#,
-            &["// 1 + 1", "// fn foo() {\n// 1 + 1\n// }"],
+            &["1", "// 1 + 1", "// fn foo() {\n// 1 + 1\n// }"],
+        );
+
+        do_check(
+            r#"
+// #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+// pub enum Direction {
+//  <|>   Next,
+//     Prev
+// }
+"#,
+            &[
+                "//     Next,",
+                "// #[derive(Debug, Clone, Copy, PartialEq, Eq)]\n// pub enum Direction {\n//     Next,\n//     Prev\n// }",
+            ],
         );
     }
 
diff --git a/crates/ra_editor/src/symbols.rs b/crates/ra_editor/src/symbols.rs
index 6d3b0514a..9e25decfb 100644
--- a/crates/ra_editor/src/symbols.rs
+++ b/crates/ra_editor/src/symbols.rs
@@ -50,6 +50,61 @@ impl FileSymbol {
             })
             .nth(0)
     }
+    /// Get a description of this node.
+    ///
+    /// e.g. `struct Name`, `enum Name`, `fn Name`
+    pub fn description(&self, file: &SourceFileNode) -> Option<String> {
+        // TODO: After type inference is done, add type information to improve the output
+        file.syntax()
+            .descendants()
+            .filter(|node| node.kind() == self.kind && node.range() == self.node_range)
+            .filter_map(|node: SyntaxNodeRef| {
+                // TODO: Refactor to be have less repetition
+                visitor()
+                    .visit(|node: ast::FnDef| {
+                        let mut string = "fn ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::StructDef| {
+                        let mut string = "struct ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::EnumDef| {
+                        let mut string = "enum ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::TraitDef| {
+                        let mut string = "trait ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::Module| {
+                        let mut string = "mod ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::TypeDef| {
+                        let mut string = "type ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::ConstDef| {
+                        let mut string = "const ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::StaticDef| {
+                        let mut string = "static ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .accept(node)?
+            })
+            .nth(0)
+    }
 }
 
 pub fn file_symbols(file: &SourceFileNode) -> Vec<FileSymbol> {
diff --git a/crates/ra_hir/src/function/mod.rs b/crates/ra_hir/src/function.rs
index 5187dc051..5187dc051 100644
--- a/crates/ra_hir/src/function/mod.rs
+++ b/crates/ra_hir/src/function.rs
diff --git a/crates/ra_hir/src/module/mod.rs b/crates/ra_hir/src/module.rs
index 580c737c3..580c737c3 100644
--- a/crates/ra_hir/src/module/mod.rs
+++ b/crates/ra_hir/src/module.rs
diff --git a/crates/ra_hir/src/module/imp.rs b/crates/ra_hir/src/module/imp.rs
index 0eec38797..9f144e139 100644
--- a/crates/ra_hir/src/module/imp.rs
+++ b/crates/ra_hir/src/module/imp.rs
@@ -164,26 +164,26 @@ fn resolve_submodule(
 
     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()
-            .filter_map(|path| file_resolver.resolve(file_id, path))
-            .collect();
-        problem = if points_to.is_empty() {
-            Some(Problem::UnresolvedModule {
-                candidate: file_mod,
-            })
-        } else {
-            None
-        }
+    let file_dir_mod = RelativePathBuf::from(format!("../{}/{}.rs", mod_name, name));
+    let tmp1;
+    let tmp2;
+    let candidates = if is_dir_owner {
+        tmp1 = [&file_mod, &dir_mod];
+        tmp1.iter()
     } else {
-        points_to = Vec::new();
-        problem = Some(Problem::NotDirOwner {
-            move_to: RelativePathBuf::from(format!("../{}/mod.rs", mod_name)),
-            candidate: file_mod,
-        });
-    }
+        tmp2 = [&file_dir_mod];
+        tmp2.iter()
+    };
+
+    let points_to = candidates
+        .filter_map(|path| file_resolver.resolve(file_id, path))
+        .collect::<Vec<_>>();
+    let problem = if points_to.is_empty() {
+        Some(Problem::UnresolvedModule {
+            candidate: if is_dir_owner { file_mod } else { file_dir_mod },
+        })
+    } else {
+        None
+    };
     (points_to, problem)
 }
diff --git a/crates/ra_lsp_server/src/main_loop/mod.rs b/crates/ra_lsp_server/src/main_loop.rs
index 0e1878906..0e1878906 100644
--- a/crates/ra_lsp_server/src/main_loop/mod.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index af21254e4..92e92f836 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -203,8 +203,12 @@ pub fn handle_goto_definition(
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<req::GotoDefinitionResponse>> {
     let position = params.try_conv_with(&world)?;
+    let rr = match world.analysis().approximately_resolve_symbol(position)? {
+        None => return Ok(None),
+        Some(it) => it,
+    };
     let mut res = Vec::new();
-    for (file_id, symbol) in world.analysis().approximately_resolve_symbol(position)? {
+    for (file_id, symbol) in rr.resolves_to {
         let line_index = world.analysis().file_line_index(file_id);
         let location = to_location(file_id, symbol.node_range, &world, &line_index)?;
         res.push(location)
@@ -504,26 +508,30 @@ pub fn handle_hover(
     world: ServerWorld,
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<Hover>> {
+    // TODO: Cut down on number of allocations
     let position = params.try_conv_with(&world)?;
     let line_index = world.analysis().file_line_index(position.file_id);
-
-    for (file_id, symbol) in world.analysis().approximately_resolve_symbol(position)? {
-        let range = symbol.node_range.conv_with(&line_index);
-        let comment = world.analysis.doc_comment_for(file_id, symbol)?;
-
-        if comment.is_some() {
-            let contents = HoverContents::Scalar(MarkedString::String(comment.unwrap()));
-
-            return Ok(Some(Hover {
-                contents,
-                range: Some(range),
-            }));
+    let rr = match world.analysis().approximately_resolve_symbol(position)? {
+        None => return Ok(None),
+        Some(it) => it,
+    };
+    let mut result = Vec::new();
+    for (file_id, symbol) in rr.resolves_to {
+        if let Some(docs) = world.analysis().doc_text_for(file_id, symbol)? {
+            result.push(docs);
         }
     }
-
+    let range = rr.reference_range.conv_with(&line_index);
+    if result.len() > 0 {
+        return Ok(Some(Hover {
+            contents: HoverContents::Scalar(MarkedString::String(result.join("\n\n---\n"))),
+            range: Some(range),
+        }));
+    }
     Ok(None)
 }
 
+/// Test doc comment
 pub fn handle_prepare_rename(
     world: ServerWorld,
     params: req::TextDocumentPositionParams,
diff --git a/crates/ra_syntax/src/algo/mod.rs b/crates/ra_syntax/src/algo.rs
index 4b3548ea9..4b3548ea9 100644
--- a/crates/ra_syntax/src/algo/mod.rs
+++ b/crates/ra_syntax/src/algo.rs
diff --git a/crates/ra_syntax/src/ast/mod.rs b/crates/ra_syntax/src/ast.rs
index 91c67119f..91c67119f 100644
--- a/crates/ra_syntax/src/ast/mod.rs
+++ b/crates/ra_syntax/src/ast.rs
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 53cd2118f..eed67637e 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -25,9 +25,9 @@ Grammar(
         ["^", "CARET"],
         ["%", "PERCENT"],
     ],
-    // TODO: Confirm surmision: the tokens which cannot be recorded in a single UTF-8 byte
+    // Tokens for which the longest match must be chosen (e.g. `..` is a DOTDOT, but `.` is a DOT)
     multi_byte_tokens: [
-        [".", "DOT"], // Note: DOT is here because <TODO: REASON>
+        [".", "DOT"],
         ["..", "DOTDOT"],
         ["...", "DOTDOTDOT"],
         ["..=", "DOTDOTEQ"],
diff --git a/crates/ra_syntax/src/grammar/mod.rs b/crates/ra_syntax/src/grammar.rs
index 06a37d648..06a37d648 100644
--- a/crates/ra_syntax/src/grammar/mod.rs
+++ b/crates/ra_syntax/src/grammar.rs
diff --git a/crates/ra_syntax/src/grammar/expressions/mod.rs b/crates/ra_syntax/src/grammar/expressions.rs
index 60c8602f9..60c8602f9 100644
--- a/crates/ra_syntax/src/grammar/expressions/mod.rs
+++ b/crates/ra_syntax/src/grammar/expressions.rs
diff --git a/crates/ra_syntax/src/grammar/items/mod.rs b/crates/ra_syntax/src/grammar/items.rs
index 4473c2fab..4473c2fab 100644
--- a/crates/ra_syntax/src/grammar/items/mod.rs
+++ b/crates/ra_syntax/src/grammar/items.rs
diff --git a/crates/ra_syntax/src/lexer/mod.rs b/crates/ra_syntax/src/lexer.rs
index f388da273..f388da273 100644
--- a/crates/ra_syntax/src/lexer/mod.rs
+++ b/crates/ra_syntax/src/lexer.rs
diff --git a/crates/ra_syntax/src/parser_impl/mod.rs b/crates/ra_syntax/src/parser_impl.rs
index cb6e370ac..cb6e370ac 100644
--- a/crates/ra_syntax/src/parser_impl/mod.rs
+++ b/crates/ra_syntax/src/parser_impl.rs
diff --git a/crates/ra_syntax/src/string_lexing/mod.rs b/crates/ra_syntax/src/string_lexing.rs
index 94853331f..94853331f 100644
--- a/crates/ra_syntax/src/string_lexing/mod.rs
+++ b/crates/ra_syntax/src/string_lexing.rs
diff --git a/crates/ra_syntax/src/syntax_kinds/mod.rs b/crates/ra_syntax/src/syntax_kinds.rs
index d53886676..d53886676 100644
--- a/crates/ra_syntax/src/syntax_kinds/mod.rs
+++ b/crates/ra_syntax/src/syntax_kinds.rs
diff --git a/crates/ra_syntax/src/syntax_kinds/generated.rs b/crates/ra_syntax/src/syntax_kinds/generated.rs
index c43a8bf65..3a869ad34 100644
--- a/crates/ra_syntax/src/syntax_kinds/generated.rs
+++ b/crates/ra_syntax/src/syntax_kinds/generated.rs
@@ -560,4 +560,3 @@ impl SyntaxKind {
         Some(tok)
     }
 }
-
diff --git a/crates/ra_syntax/src/syntax_kinds/generated.rs.tera b/crates/ra_syntax/src/syntax_kinds/generated.rs.tera
index c37e57702..21f9444b1 100644
--- a/crates/ra_syntax/src/syntax_kinds/generated.rs.tera
+++ b/crates/ra_syntax/src/syntax_kinds/generated.rs.tera
@@ -75,4 +75,3 @@ impl SyntaxKind {
         Some(tok)
     }
 }
-
diff --git a/crates/ra_syntax/src/validation/mod.rs b/crates/ra_syntax/src/validation.rs
index bdee8120c..bdee8120c 100644
--- a/crates/ra_syntax/src/validation/mod.rs
+++ b/crates/ra_syntax/src/validation.rs
diff --git a/crates/ra_syntax/src/yellow/mod.rs b/crates/ra_syntax/src/yellow.rs
index cacd89dc8..cacd89dc8 100644
--- a/crates/ra_syntax/src/yellow/mod.rs
+++ b/crates/ra_syntax/src/yellow.rs
diff --git a/crates/tools/src/main.rs b/crates/tools/src/main.rs
index e312df537..36a7c83e2 100644
--- a/crates/tools/src/main.rs
+++ b/crates/tools/src/main.rs
@@ -79,15 +79,21 @@ fn tests_from_dir(dir: &Path) -> Result<HashMap<String, Test>> {
         if entry.path().extension().unwrap_or_default() != "rs" {
             continue;
         }
-        let text = fs::read_to_string(entry.path())?;
+        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 HashMap<String, Test>, path: &Path) -> Result<()> {
+        let text = fs::read_to_string(path)?;
 
         for (_, test) in collect_tests(&text) {
             if let Some(old_test) = res.insert(test.name.clone(), test) {
                 bail!("Duplicate test: {}", old_test.name)
             }
         }
+        Ok(())
     }
-    Ok(res)
 }
 
 fn existing_tests(dir: &Path) -> Result<HashMap<String, (PathBuf, Test)>> {