8 files changed, 148 insertions, 350 deletions

diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index 7cd2384e9..8b06cbfc5 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -14,7 +14,6 @@ use ra_syntax::{
     ast::{self, AstNode},
     match_ast,
 };
-use test_utils::tested_by;
 
 use crate::RootDatabase;
 
@@ -42,12 +41,10 @@ impl Definition {
     }
 
     pub fn visibility(&self, db: &RootDatabase) -> Option<Visibility> {
-        let module = self.module(db);
-
         match self {
             Definition::Macro(_) => None,
             Definition::Field(sf) => Some(sf.visibility(db)),
-            Definition::ModuleDef(def) => module?.visibility_of(db, def),
+            Definition::ModuleDef(def) => def.definition_visibility(db),
             Definition::SelfType(_) => None,
             Definition::Local(_) => None,
             Definition::TypeParam(_) => None,
@@ -119,6 +116,15 @@ fn classify_name_inner(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Opti
 
     match_ast! {
         match parent {
+            ast::Alias(it) => {
+                let use_tree = it.syntax().parent().and_then(ast::UseTree::cast)?;
+                let path = use_tree.path()?;
+                let path_segment = path.segment()?;
+                let name_ref = path_segment.name_ref()?;
+                let name_ref_class = classify_name_ref(sema, &name_ref)?;
+
+                Some(name_ref_class.definition())
+            },
             ast::BindPat(it) => {
                 let local = sema.to_def(&it)?;
                 Some(Definition::Local(local))
@@ -195,6 +201,8 @@ impl NameRefClass {
     }
 }
 
+// Note: we don't have unit-tests for this rather important function.
+// It is primarily exercised via goto definition tests in `ra_ide`.
 pub fn classify_name_ref(
     sema: &Semantics<RootDatabase>,
     name_ref: &ast::NameRef,
@@ -204,22 +212,18 @@ pub fn classify_name_ref(
     let parent = name_ref.syntax().parent()?;
 
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
-        tested_by!(goto_def_for_methods; force);
         if let Some(func) = sema.resolve_method_call(&method_call) {
             return Some(NameRefClass::Definition(Definition::ModuleDef(func.into())));
         }
     }
 
     if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
-        tested_by!(goto_def_for_fields; force);
         if let Some(field) = sema.resolve_field(&field_expr) {
             return Some(NameRefClass::Definition(Definition::Field(field)));
         }
     }
 
     if let Some(record_field) = ast::RecordField::for_field_name(name_ref) {
-        tested_by!(goto_def_for_record_fields; force);
-        tested_by!(goto_def_for_field_init_shorthand; force);
         if let Some((field, local)) = sema.resolve_record_field(&record_field) {
             let field = Definition::Field(field);
             let res = match local {
@@ -231,7 +235,6 @@ pub fn classify_name_ref(
     }
 
     if let Some(record_field_pat) = ast::RecordFieldPat::cast(parent.clone()) {
-        tested_by!(goto_def_for_record_field_pats; force);
         if let Some(field) = sema.resolve_record_field_pat(&record_field_pat) {
             let field = Definition::Field(field);
             return Some(NameRefClass::Definition(field));
@@ -239,7 +242,6 @@ pub fn classify_name_ref(
     }
 
     if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
-        tested_by!(goto_def_for_macros; force);
         if let Some(macro_def) = sema.resolve_macro_call(&macro_call) {
             return Some(NameRefClass::Definition(Definition::Macro(macro_def)));
         }
diff --git a/crates/ra_ide_db/src/lib.rs b/crates/ra_ide_db/src/lib.rs
index e6f2d36e9..1b74e6558 100644
--- a/crates/ra_ide_db/src/lib.rs
+++ b/crates/ra_ide_db/src/lib.rs
@@ -2,14 +2,13 @@
 //!
 //! It is mainly a `HirDatabase` for semantic analysis, plus a `SymbolsDatabase`, for fuzzy search.
 
-pub mod marks;
 pub mod line_index;
-pub mod line_index_utils;
 pub mod symbol_index;
 pub mod change;
 pub mod defs;
 pub mod search;
 pub mod imports_locator;
+pub mod source_change;
 mod wasm_shims;
 
 use std::sync::Arc;
diff --git a/crates/ra_ide_db/src/line_index.rs b/crates/ra_ide_db/src/line_index.rs
index 00ba95913..c7c744fce 100644
--- a/crates/ra_ide_db/src/line_index.rs
+++ b/crates/ra_ide_db/src/line_index.rs
@@ -8,7 +8,9 @@ use superslice::Ext;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct LineIndex {
+    /// Offset the the beginning of each line, zero-based
     pub(crate) newlines: Vec<TextSize>,
+    /// List of non-ASCII characters on each line
     pub(crate) utf16_lines: FxHashMap<u32, Vec<Utf16Char>>,
 }
 
@@ -22,14 +24,26 @@ pub struct LineCol {
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub(crate) struct Utf16Char {
+    /// Start offset of a character inside a line, zero-based
     pub(crate) start: TextSize,
+    /// End offset of a character inside a line, zero-based
     pub(crate) end: TextSize,
 }
 
 impl Utf16Char {
+    /// Returns the length in 8-bit UTF-8 code units.
     fn len(&self) -> TextSize {
         self.end - self.start
     }
+
+    /// Returns the length in 16-bit UTF-16 code units.
+    fn len_utf16(&self) -> usize {
+        if self.len() == TextSize::from(4) {
+            2
+        } else {
+            1
+        }
+    }
 }
 
 impl LineIndex {
@@ -106,7 +120,7 @@ impl LineIndex {
         if let Some(utf16_chars) = self.utf16_lines.get(&line) {
             for c in utf16_chars {
                 if c.end <= col {
-                    res -= usize::from(c.len()) - 1;
+                    res -= usize::from(c.len()) - c.len_utf16();
                 } else {
                     // From here on, all utf16 characters come *after* the character we are mapping,
                     // so we don't need to take them into account
@@ -120,8 +134,8 @@ impl LineIndex {
     fn utf16_to_utf8_col(&self, line: u32, mut col: u32) -> TextSize {
         if let Some(utf16_chars) = self.utf16_lines.get(&line) {
             for c in utf16_chars {
-                if col >= u32::from(c.start) {
-                    col += u32::from(c.len()) - 1;
+                if col > u32::from(c.start) {
+                    col += u32::from(c.len()) - c.len_utf16() as u32;
                 } else {
                     // From here on, all utf16 characters come *after* the character we are mapping,
                     // so we don't need to take them into account
@@ -200,6 +214,9 @@ const C: char = 'メ';
 
         // UTF-16 to UTF-8
         assert_eq!(col_index.utf16_to_utf8_col(1, 19), TextSize::from(21));
+
+        let col_index = LineIndex::new("a𐐏b");
+        assert_eq!(col_index.utf16_to_utf8_col(0, 3), TextSize::from(5));
     }
 
     #[test]
@@ -226,8 +243,10 @@ const C: char = \"メ メ\";
         // UTF-16 to UTF-8
         assert_eq!(col_index.utf16_to_utf8_col(1, 15), TextSize::from(15));
 
-        assert_eq!(col_index.utf16_to_utf8_col(1, 18), TextSize::from(20));
-        assert_eq!(col_index.utf16_to_utf8_col(1, 19), TextSize::from(23));
+        // メ UTF-8: 0xE3 0x83 0xA1, UTF-16: 0x30E1
+        assert_eq!(col_index.utf16_to_utf8_col(1, 17), TextSize::from(17)); // first メ at 17..20
+        assert_eq!(col_index.utf16_to_utf8_col(1, 18), TextSize::from(20)); // space
+        assert_eq!(col_index.utf16_to_utf8_col(1, 19), TextSize::from(21)); // second メ at 21..24
 
         assert_eq!(col_index.utf16_to_utf8_col(2, 15), TextSize::from(15));
     }
diff --git a/crates/ra_ide_db/src/line_index_utils.rs b/crates/ra_ide_db/src/line_index_utils.rs
deleted file mode 100644
index 039a12c0d..000000000
--- a/crates/ra_ide_db/src/line_index_utils.rs
+++ /dev/null
@@ -1,302 +0,0 @@
-//! Code actions can specify desirable final position of the cursor.
-//!
-//! The position is specified as a `TextSize` in the final file. We need to send
-//! it in `(Line, Column)` coordinate though. However, we only have a LineIndex
-//! for a file pre-edit!
-//!
-//! Code in this module applies this "to (Line, Column) after edit"
-//! transformation.
-
-use std::convert::TryInto;
-
-use ra_syntax::{TextRange, TextSize};
-use ra_text_edit::{AtomTextEdit, TextEdit};
-
-use crate::line_index::{LineCol, LineIndex, Utf16Char};
-
-pub fn translate_offset_with_edit(
-    line_index: &LineIndex,
-    offset: TextSize,
-    text_edit: &TextEdit,
-) -> LineCol {
-    let mut state = Edits::from_text_edit(&text_edit);
-
-    let mut res = RunningLineCol::new();
-
-    macro_rules! test_step {
-        ($x:ident) => {
-            match &$x {
-                Step::Newline(n) => {
-                    if offset < *n {
-                        return res.to_line_col(offset);
-                    } else {
-                        res.add_line(*n);
-                    }
-                }
-                Step::Utf16Char(x) => {
-                    if offset < x.end() {
-                        // if the offset is inside a multibyte char it's invalid
-                        // clamp it to the start of the char
-                        let clamp = offset.min(x.start());
-                        return res.to_line_col(clamp);
-                    } else {
-                        res.adjust_col(*x);
-                    }
-                }
-            }
-        };
-    }
-
-    for orig_step in LineIndexStepIter::from(line_index) {
-        loop {
-            let translated_step = state.translate_step(&orig_step);
-            match state.next_steps(&translated_step) {
-                NextSteps::Use => {
-                    test_step!(translated_step);
-                    break;
-                }
-                NextSteps::ReplaceMany(ns) => {
-                    for n in ns {
-                        test_step!(n);
-                    }
-                    break;
-                }
-                NextSteps::AddMany(ns) => {
-                    for n in ns {
-                        test_step!(n);
-                    }
-                }
-            }
-        }
-    }
-
-    loop {
-        match state.next_inserted_steps() {
-            None => break,
-            Some(ns) => {
-                for n in ns {
-                    test_step!(n);
-                }
-            }
-        }
-    }
-
-    res.to_line_col(offset)
-}
-
-#[derive(Debug, Clone)]
-enum Step {
-    Newline(TextSize),
-    Utf16Char(TextRange),
-}
-
-#[derive(Debug)]
-struct LineIndexStepIter<'a> {
-    line_index: &'a LineIndex,
-    next_newline_idx: usize,
-    utf16_chars: Option<(TextSize, std::slice::Iter<'a, Utf16Char>)>,
-}
-
-impl LineIndexStepIter<'_> {
-    fn from(line_index: &LineIndex) -> LineIndexStepIter {
-        let mut x = LineIndexStepIter { line_index, next_newline_idx: 0, utf16_chars: None };
-        // skip first newline since it's not real
-        x.next();
-        x
-    }
-}
-
-impl Iterator for LineIndexStepIter<'_> {
-    type Item = Step;
-    fn next(&mut self) -> Option<Step> {
-        self.utf16_chars
-            .as_mut()
-            .and_then(|(newline, x)| {
-                let x = x.next()?;
-                Some(Step::Utf16Char(TextRange::new(*newline + x.start, *newline + x.end)))
-            })
-            .or_else(|| {
-                let next_newline = *self.line_index.newlines.get(self.next_newline_idx)?;
-                self.utf16_chars = self
-                    .line_index
-                    .utf16_lines
-                    .get(&(self.next_newline_idx as u32))
-                    .map(|x| (next_newline, x.iter()));
-                self.next_newline_idx += 1;
-                Some(Step::Newline(next_newline))
-            })
-    }
-}
-
-#[derive(Debug)]
-struct OffsetStepIter<'a> {
-    text: &'a str,
-    offset: TextSize,
-}
-
-impl Iterator for OffsetStepIter<'_> {
-    type Item = Step;
-    fn next(&mut self) -> Option<Step> {
-        let (next, next_offset) = self
-            .text
-            .char_indices()
-            .filter_map(|(i, c)| {
-                let i: TextSize = i.try_into().unwrap();
-                let char_len = TextSize::of(c);
-                if c == '\n' {
-                    let next_offset = self.offset + i + char_len;
-                    let next = Step::Newline(next_offset);
-                    Some((next, next_offset))
-                } else {
-                    if !c.is_ascii() {
-                        let start = self.offset + i;
-                        let end = start + char_len;
-                        let next = Step::Utf16Char(TextRange::new(start, end));
-                        let next_offset = end;
-                        Some((next, next_offset))
-                    } else {
-                        None
-                    }
-                }
-            })
-            .next()?;
-        let next_idx: usize = (next_offset - self.offset).into();
-        self.text = &self.text[next_idx..];
-        self.offset = next_offset;
-        Some(next)
-    }
-}
-
-#[derive(Debug)]
-enum NextSteps<'a> {
-    Use,
-    ReplaceMany(OffsetStepIter<'a>),
-    AddMany(OffsetStepIter<'a>),
-}
-
-#[derive(Debug)]
-struct TranslatedEdit<'a> {
-    delete: TextRange,
-    insert: &'a str,
-    diff: i64,
-}
-
-struct Edits<'a> {
-    edits: &'a [AtomTextEdit],
-    current: Option<TranslatedEdit<'a>>,
-    acc_diff: i64,
-}
-
-impl<'a> Edits<'a> {
-    fn from_text_edit(text_edit: &'a TextEdit) -> Edits<'a> {
-        let mut x = Edits { edits: text_edit.as_atoms(), current: None, acc_diff: 0 };
-        x.advance_edit();
-        x
-    }
-    fn advance_edit(&mut self) {
-        self.acc_diff += self.current.as_ref().map_or(0, |x| x.diff);
-        match self.edits.split_first() {
-            Some((next, rest)) => {
-                let delete = self.translate_range(next.delete);
-                let diff = next.insert.len() as i64 - usize::from(next.delete.len()) as i64;
-                self.current = Some(TranslatedEdit { delete, insert: &next.insert, diff });
-                self.edits = rest;
-            }
-            None => {
-                self.current = None;
-            }
-        }
-    }
-
-    fn next_inserted_steps(&mut self) -> Option<OffsetStepIter<'a>> {
-        let cur = self.current.as_ref()?;
-        let res = Some(OffsetStepIter { offset: cur.delete.start(), text: &cur.insert });
-        self.advance_edit();
-        res
-    }
-
-    fn next_steps(&mut self, step: &Step) -> NextSteps {
-        let step_pos = match *step {
-            Step::Newline(n) => n,
-            Step::Utf16Char(r) => r.end(),
-        };
-        match &mut self.current {
-            Some(edit) => {
-                if step_pos <= edit.delete.start() {
-                    NextSteps::Use
-                } else if step_pos <= edit.delete.end() {
-                    let iter = OffsetStepIter { offset: edit.delete.start(), text: &edit.insert };
-                    // empty slice to avoid returning steps again
-                    edit.insert = &edit.insert[edit.insert.len()..];
-                    NextSteps::ReplaceMany(iter)
-                } else {
-                    let iter = OffsetStepIter { offset: edit.delete.start(), text: &edit.insert };
-                    // empty slice to avoid returning steps again
-                    edit.insert = &edit.insert[edit.insert.len()..];
-                    self.advance_edit();
-                    NextSteps::AddMany(iter)
-                }
-            }
-            None => NextSteps::Use,
-        }
-    }
-
-    fn translate_range(&self, range: TextRange) -> TextRange {
-        if self.acc_diff == 0 {
-            range
-        } else {
-            let start = self.translate(range.start());
-            let end = self.translate(range.end());
-            TextRange::new(start, end)
-        }
-    }
-
-    fn translate(&self, x: TextSize) -> TextSize {
-        if self.acc_diff == 0 {
-            x
-        } else {
-            TextSize::from((usize::from(x) as i64 + self.acc_diff) as u32)
-        }
-    }
-
-    fn translate_step(&self, x: &Step) -> Step {
-        if self.acc_diff == 0 {
-            x.clone()
-        } else {
-            match *x {
-                Step::Newline(n) => Step::Newline(self.translate(n)),
-                Step::Utf16Char(r) => Step::Utf16Char(self.translate_range(r)),
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-struct RunningLineCol {
-    line: u32,
-    last_newline: TextSize,
-    col_adjust: TextSize,
-}
-
-impl RunningLineCol {
-    fn new() -> RunningLineCol {
-        RunningLineCol { line: 0, last_newline: TextSize::from(0), col_adjust: TextSize::from(0) }
-    }
-
-    fn to_line_col(&self, offset: TextSize) -> LineCol {
-        LineCol {
-            line: self.line,
-            col_utf16: ((offset - self.last_newline) - self.col_adjust).into(),
-        }
-    }
-
-    fn add_line(&mut self, newline: TextSize) {
-        self.line += 1;
-        self.last_newline = newline;
-        self.col_adjust = TextSize::from(0);
-    }
-
-    fn adjust_col(&mut self, range: TextRange) {
-        self.col_adjust += range.len() - TextSize::from(1);
-    }
-}
diff --git a/crates/ra_ide_db/src/marks.rs b/crates/ra_ide_db/src/marks.rs
deleted file mode 100644
index 03b4be21c..000000000
--- a/crates/ra_ide_db/src/marks.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! See test_utils/src/marks.rs
-
-test_utils::marks![
-    goto_def_for_macros
-    goto_def_for_methods
-    goto_def_for_fields
-    goto_def_for_record_fields
-    goto_def_for_field_init_shorthand
-    goto_def_for_record_field_pats
-    search_filters_by_range
-];
diff --git a/crates/ra_ide_db/src/search.rs b/crates/ra_ide_db/src/search.rs
index b464959fc..335a1ad03 100644
--- a/crates/ra_ide_db/src/search.rs
+++ b/crates/ra_ide_db/src/search.rs
@@ -12,7 +12,6 @@ use ra_db::{FileId, FileRange, SourceDatabaseExt};
 use ra_prof::profile;
 use ra_syntax::{ast, match_ast, AstNode, TextRange, TextSize};
 use rustc_hash::FxHashMap;
-use test_utils::tested_by;
 
 use crate::{
     defs::{classify_name_ref, Definition, NameRefClass},
@@ -125,29 +124,33 @@ impl Definition {
 
         let vis = self.visibility(db);
 
-        // FIXME:
-        // The following logic are wrong that it does not search
-        // for submodules within other files recursively.
-
         if let Some(Visibility::Module(module)) = vis.and_then(|it| it.into()) {
             let module: Module = module.into();
             let mut res = FxHashMap::default();
-            let src = module.definition_source(db);
-            let file_id = src.file_id.original_file(db);
 
-            match src.value {
-                ModuleSource::Module(m) => {
-                    let range = Some(m.syntax().text_range());
-                    res.insert(file_id, range);
-                }
-                ModuleSource::SourceFile(_) => {
-                    res.insert(file_id, None);
-                    res.extend(module.children(db).map(|m| {
-                        let src = m.definition_source(db);
-                        (src.file_id.original_file(db), None)
-                    }));
-                }
+            let mut to_visit = vec![module];
+            let mut is_first = true;
+            while let Some(module) = to_visit.pop() {
+                let src = module.definition_source(db);
+                let file_id = src.file_id.original_file(db);
+                match src.value {
+                    ModuleSource::Module(m) => {
+                        if is_first {
+                            let range = Some(m.syntax().text_range());
+                            res.insert(file_id, range);
+                        } else {
+                            // We have already added the enclosing file to the search scope,
+                            // so do nothing.
+                        }
+                    }
+                    ModuleSource::SourceFile(_) => {
+                        res.insert(file_id, None);
+                    }
+                };
+                is_first = false;
+                to_visit.extend(module.children(db));
             }
+
             return SearchScope::new(res);
         }
 
@@ -209,7 +212,6 @@ impl Definition {
             for (idx, _) in text.match_indices(pat) {
                 let offset: TextSize = idx.try_into().unwrap();
                 if !search_range.contains_inclusive(offset) {
-                    tested_by!(search_filters_by_range; force);
                     continue;
                 }
 
diff --git a/crates/ra_ide_db/src/source_change.rs b/crates/ra_ide_db/src/source_change.rs
new file mode 100644
index 000000000..e713f4b7e
--- /dev/null
+++ b/crates/ra_ide_db/src/source_change.rs
@@ -0,0 +1,68 @@
+//! This modules defines type to represent changes to the source code, that flow
+//! from the server to the client.
+//!
+//! It can be viewed as a dual for `AnalysisChange`.
+
+use ra_db::{FileId, RelativePathBuf, SourceRootId};
+use ra_text_edit::TextEdit;
+
+#[derive(Debug, Clone)]
+pub struct SourceChange {
+    pub source_file_edits: Vec<SourceFileEdit>,
+    pub file_system_edits: Vec<FileSystemEdit>,
+    pub is_snippet: bool,
+}
+
+impl SourceChange {
+    /// Creates a new SourceChange with the given label
+    /// from the edits.
+    pub fn from_edits(
+        source_file_edits: Vec<SourceFileEdit>,
+        file_system_edits: Vec<FileSystemEdit>,
+    ) -> Self {
+        SourceChange { source_file_edits, file_system_edits, is_snippet: false }
+    }
+
+    /// Creates a new SourceChange with the given label,
+    /// containing only the given `SourceFileEdits`.
+    pub fn source_file_edits(edits: Vec<SourceFileEdit>) -> Self {
+        SourceChange { source_file_edits: edits, file_system_edits: vec![], is_snippet: false }
+    }
+    /// Creates a new SourceChange with the given label
+    /// from the given `FileId` and `TextEdit`
+    pub fn source_file_edit_from(file_id: FileId, edit: TextEdit) -> Self {
+        SourceFileEdit { file_id, edit }.into()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SourceFileEdit {
+    pub file_id: FileId,
+    pub edit: TextEdit,
+}
+
+impl From<SourceFileEdit> for SourceChange {
+    fn from(edit: SourceFileEdit) -> SourceChange {
+        SourceChange {
+            source_file_edits: vec![edit],
+            file_system_edits: Vec::new(),
+            is_snippet: false,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum FileSystemEdit {
+    CreateFile { source_root: SourceRootId, path: RelativePathBuf },
+    MoveFile { src: FileId, dst_source_root: SourceRootId, dst_path: RelativePathBuf },
+}
+
+impl From<FileSystemEdit> for SourceChange {
+    fn from(edit: FileSystemEdit) -> SourceChange {
+        SourceChange {
+            source_file_edits: Vec::new(),
+            file_system_edits: vec![edit],
+            is_snippet: false,
+        }
+    }
+}
diff --git a/crates/ra_ide_db/src/symbol_index.rs b/crates/ra_ide_db/src/symbol_index.rs
index 95be11134..acc31fe3b 100644
--- a/crates/ra_ide_db/src/symbol_index.rs
+++ b/crates/ra_ide_db/src/symbol_index.rs
@@ -110,6 +110,27 @@ fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Arc<SymbolIndex>
     Arc::new(SymbolIndex::new(symbols))
 }
 
+// Feature: Workspace Symbol
+//
+// Uses fuzzy-search to find types, modules and functions by name across your
+// project and dependencies. This is **the** most useful feature, which improves code
+// navigation tremendously. It mostly works on top of the built-in LSP
+// functionality, however `#` and `*` symbols can be used to narrow down the
+// search. Specifically,
+//
+// - `Foo` searches for `Foo` type in the current workspace
+// - `foo#` searches for `foo` function in the current workspace
+// - `Foo*` searches for `Foo` type among dependencies, including `stdlib`
+// - `foo#*` searches for `foo` function among dependencies
+//
+// That is, `#` switches from "types" to all symbols, `*` switches from the current
+// workspace to dependencies.
+//
+// |===
+// | Editor  | Shortcut
+//
+// | VS Code | kbd:[Ctrl+T]
+// |===
 pub fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol> {
     /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
     struct Snap(salsa::Snapshot<RootDatabase>);