12 files changed, 194 insertions, 79 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 51cf1825d..69134b434 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -668,6 +668,7 @@ dependencies = [
 name = "ra_db"
 version = "0.1.0"
 dependencies = [
+ "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "ra_editor 0.1.0",
  "ra_syntax 0.1.0",
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index a547c5a20..38a5c1a7d 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -3,31 +3,32 @@ use std::{
     sync::Arc,
 };
 
-use ra_editor::{self, find_node_at_offset, FileSymbol, LineIndex, LocalEdit, Severity};
-use ra_syntax::{
-    ast::{self, ArgListOwner, Expr, NameOwner, FnDef},
-    algo::find_covering_node,
-    AstNode, SourceFileNode,
-    SyntaxKind::*,
-    SyntaxNodeRef, TextRange, TextUnit,
-};
-use ra_db::{FilesDatabase, SourceRoot, SourceRootId, SyntaxDatabase};
 use rayon::prelude::*;
 use salsa::{Database, ParallelDatabase};
+
 use hir::{
     self,
-    source_binder,
     FnSignatureInfo,
     Problem,
+    source_binder,
+};
+use ra_db::{FilesDatabase, SourceRoot, SourceRootId, SyntaxDatabase};
+use ra_editor::{self, FileSymbol, find_node_at_offset, LineIndex, LocalEdit, Severity};
+use ra_syntax::{
+    algo::find_covering_node,
+    ast::{self, ArgListOwner, Expr, FnDef, NameOwner},
+    AstNode, SourceFileNode,
+    SyntaxKind::*,
+    SyntaxNodeRef, TextRange, TextUnit,
 };
 
 use crate::{
-    completion::{completions, CompletionItem},
-    db,
-    symbol_index::{SymbolIndex, SymbolsDatabase, LibrarySymbolsQuery},
-    AnalysisChange, RootChange, Cancelable, CrateId, Diagnostic, FileId,
-    FileSystemEdit, FilePosition, Query, SourceChange, SourceFileEdit,
-    ReferenceResolution,
+    AnalysisChange,
+    Cancelable,
+    completion::{CompletionItem, completions},
+    CrateId, db, Diagnostic, FileId, FilePosition, FileSystemEdit,
+    Query, ReferenceResolution, RootChange, SourceChange, SourceFileEdit,
+    symbol_index::{LibrarySymbolsQuery, SymbolIndex, SymbolsDatabase},
 };
 
 #[derive(Debug, Default)]
@@ -366,7 +367,7 @@ impl AnalysisImpl {
                 range: d.range,
                 message: d.msg,
                 severity: d.severity,
-                fix: None,
+                fix: d.fix.map(|fix| SourceChange::from_local_edit(file_id, fix)),
             })
             .collect::<Vec<_>>();
         if let Some(m) = source_binder::module_from_file_id(&*self.db, file_id)? {
@@ -425,25 +426,15 @@ 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()),
-            ),
-            ("add impl", ra_editor::add_impl(&file, offset).map(|f| f())),
-            (
-                "introduce variable",
-                ra_editor::introduce_variable(&file, range).map(|f| f()),
-            ),
+            ra_editor::flip_comma(&file, offset).map(|f| f()),
+            ra_editor::add_derive(&file, offset).map(|f| f()),
+            ra_editor::add_impl(&file, offset).map(|f| f()),
+            ra_editor::make_pub_crate(&file, offset).map(|f| f()),
+            ra_editor::introduce_variable(&file, range).map(|f| f()),
         ];
         actions
             .into_iter()
-            .filter_map(|(name, local_edit)| {
-                Some(SourceChange::from_local_edit(file_id, name, local_edit?))
-            })
+            .filter_map(|local_edit| Some(SourceChange::from_local_edit(file_id, local_edit?)))
             .collect()
     }
 
@@ -541,13 +532,13 @@ impl AnalysisImpl {
 }
 
 impl SourceChange {
-    pub(crate) fn from_local_edit(file_id: FileId, label: &str, edit: LocalEdit) -> SourceChange {
+    pub(crate) fn from_local_edit(file_id: FileId, edit: LocalEdit) -> SourceChange {
         let file_edit = SourceFileEdit {
             file_id,
             edit: edit.edit,
         };
         SourceChange {
-            label: label.to_string(),
+            label: edit.label,
             source_file_edits: vec![file_edit],
             file_system_edits: vec![],
             cursor_position: edit
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index a029f66b4..476d1b438 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -288,19 +288,18 @@ impl Analysis {
     }
     pub fn join_lines(&self, file_id: FileId, range: TextRange) -> SourceChange {
         let file = self.imp.file_syntax(file_id);
-        SourceChange::from_local_edit(file_id, "join lines", ra_editor::join_lines(&file, range))
+        SourceChange::from_local_edit(file_id, ra_editor::join_lines(&file, range))
     }
     pub fn on_enter(&self, position: FilePosition) -> Option<SourceChange> {
         let file = self.imp.file_syntax(position.file_id);
         let edit = ra_editor::on_enter(&file, position.offset)?;
-        let res = SourceChange::from_local_edit(position.file_id, "on enter", edit);
+        let res = SourceChange::from_local_edit(position.file_id, edit);
         Some(res)
     }
     pub fn on_eq_typed(&self, position: FilePosition) -> Option<SourceChange> {
         let file = self.imp.file_syntax(position.file_id);
         Some(SourceChange::from_local_edit(
             position.file_id,
-            "add semicolon",
             ra_editor::on_eq_typed(&file, position.offset)?,
         ))
     }
diff --git a/crates/ra_db/Cargo.toml b/crates/ra_db/Cargo.toml
index f316c0ab2..4be32b5f3 100644
--- a/crates/ra_db/Cargo.toml
+++ b/crates/ra_db/Cargo.toml
@@ -5,6 +5,7 @@ version = "0.1.0"
 authors = ["Aleksey Kladov <[email protected]>"]
 
 [dependencies]
+backtrace = "0.3.1"
 relative-path = "0.4.0"
 salsa = "0.8.0"
 rustc-hash = "1.0"
diff --git a/crates/ra_db/src/cancelation.rs b/crates/ra_db/src/cancelation.rs
new file mode 100644
index 000000000..73444b015
--- /dev/null
+++ b/crates/ra_db/src/cancelation.rs
@@ -0,0 +1,85 @@
+//! Utility types to support cancellation.
+//!
+//! In a typical IDE use-case, requests and modification happen concurrently, as
+//! in the following scenario:
+//!
+//!   * user types a character,
+//!   * a syntax highlighting process is started
+//!   * user types next character, while syntax highlighting *is still in
+//!     progress*.
+//!
+//! In this situation, we want to react to modification as quckly as possible.
+//! At the same time, in-progress results are not very interesting, because they
+//! are invalidated by the edit anyway. So, we first cancel all in-flight
+//! requests, and then apply modification knowing that it won't intrfere with
+//! any background processing (this bit is handled by salsa, see
+//! `BaseDatabase::check_canceled` method).
+
+use std::{
+    cmp,
+    hash::{Hash, Hasher},
+    sync::Arc,
+};
+
+use backtrace::Backtrace;
+use parking_lot::Mutex;
+
+/// An "error" signifing that the operation was canceled.
+#[derive(Clone)]
+pub struct Canceled {
+    backtrace: Arc<Mutex<Backtrace>>,
+}
+
+pub type Cancelable<T> = Result<T, Canceled>;
+
+impl Canceled {
+    pub(crate) fn new() -> Canceled {
+        let bt = Backtrace::new_unresolved();
+        Canceled {
+            backtrace: Arc::new(Mutex::new(bt)),
+        }
+    }
+}
+
+impl std::fmt::Display for Canceled {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fmt.write_str("canceled")
+    }
+}
+
+impl std::fmt::Debug for Canceled {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut bt = self.backtrace.lock();
+        let bt: &mut Backtrace = &mut *bt;
+        bt.resolve();
+        write!(fmt, "canceled at:\n{:?}", bt)
+    }
+}
+
+impl std::error::Error for Canceled {}
+
+impl PartialEq for Canceled {
+    fn eq(&self, _: &Canceled) -> bool {
+        true
+    }
+}
+
+impl Eq for Canceled {}
+
+impl Hash for Canceled {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        ().hash(hasher)
+    }
+}
+
+impl cmp::Ord for Canceled {
+    fn cmp(&self, _: &Canceled) -> cmp::Ordering {
+        cmp::Ordering::Equal
+    }
+}
+
+impl cmp::PartialOrd for Canceled {
+    fn partial_cmp(&self, other: &Canceled) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index 78f2cbf12..1f7c9187b 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -1,27 +1,17 @@
 //! ra_db defines basic database traits. Concrete DB is defined by ra_analysis.
+mod cancelation;
 mod syntax_ptr;
 mod input;
 mod loc2id;
 pub mod mock;
 
 use std::sync::Arc;
+
 use ra_editor::LineIndex;
 use ra_syntax::{TextUnit, SourceFileNode};
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct Canceled;
-
-pub type Cancelable<T> = Result<T, Canceled>;
-
-impl std::fmt::Display for Canceled {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        fmt.write_str("canceled")
-    }
-}
-
-impl std::error::Error for Canceled {}
-
 pub use crate::{
+    cancelation::{Canceled, Cancelable},
     syntax_ptr::LocalSyntaxPtr,
     input::{
         FilesDatabase, FileId, CrateId, SourceRoot, SourceRootId, CrateGraph,
@@ -48,7 +38,7 @@ macro_rules! impl_numeric_id {
 pub trait BaseDatabase: salsa::Database {
     fn check_canceled(&self) -> Cancelable<()> {
         if self.salsa_runtime().is_current_revision_canceled() {
-            Err(Canceled)
+            Err(Canceled::new())
         } else {
             Ok(())
         }
diff --git a/crates/ra_editor/src/code_actions.rs b/crates/ra_editor/src/code_actions.rs
index 1d78cb7e8..7615f37a6 100644
--- a/crates/ra_editor/src/code_actions.rs
+++ b/crates/ra_editor/src/code_actions.rs
@@ -12,6 +12,7 @@ use crate::{find_node_at_offset, TextEdit, TextEditBuilder};
 
 #[derive(Debug)]
 pub struct LocalEdit {
+    pub label: String,
     pub edit: TextEdit,
     pub cursor_position: Option<TextUnit>,
 }
@@ -30,6 +31,7 @@ pub fn flip_comma<'a>(
         edit.replace(prev.range(), next.text().to_string());
         edit.replace(next.range(), prev.text().to_string());
         LocalEdit {
+            label: "flip comma".to_string(),
             edit: edit.finish(),
             cursor_position: None,
         }
@@ -58,6 +60,7 @@ pub fn add_derive<'a>(
             Some(tt) => tt.syntax().range().end() - TextUnit::of_char(')'),
         };
         LocalEdit {
+            label: "add `#[derive]`".to_string(),
             edit: edit.finish(),
             cursor_position: Some(offset),
         }
@@ -109,6 +112,7 @@ pub fn add_impl<'a>(
         buf.push_str("\n}");
         edit.insert(start_offset, buf);
         LocalEdit {
+            label: "add impl".to_string(),
             edit: edit.finish(),
             cursor_position: Some(offset),
         }
@@ -148,6 +152,7 @@ pub fn introduce_variable<'a>(
         }
         let cursor_position = anchor_stmt.range().start() + TextUnit::of_str("let ");
         LocalEdit {
+            label: "introduce variable".to_string(),
             edit: edit.finish(),
             cursor_position: Some(cursor_position),
         }
@@ -194,6 +199,7 @@ pub fn make_pub_crate<'a>(
             || parent.children().any(|child| child.kind() == VISIBILITY)
         {
             return LocalEdit {
+                label: "make pub crate".to_string(),
                 edit: edit.finish(),
                 cursor_position: Some(offset),
             };
@@ -201,6 +207,7 @@ pub fn make_pub_crate<'a>(
 
         edit.insert(node_start, "pub(crate) ".to_string());
         LocalEdit {
+            label: "make pub crate".to_string(),
             edit: edit.finish(),
             cursor_position: Some(node_start),
         }
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
index 7a689b0f2..dcf8be5a7 100644
--- a/crates/ra_editor/src/lib.rs
+++ b/crates/ra_editor/src/lib.rs
@@ -42,6 +42,7 @@ pub struct Diagnostic {
     pub range: TextRange,
     pub msg: String,
     pub severity: Severity,
+    pub fix: Option<LocalEdit>,
 }
 
 #[derive(Debug)]
@@ -111,6 +112,7 @@ pub fn diagnostics(file: &SourceFileNode) -> Vec<Diagnostic> {
             range: location_to_range(err.location()),
             msg: format!("Syntax Error: {}", err),
             severity: Severity::Error,
+            fix: None,
         })
         .collect();
 
@@ -124,11 +126,30 @@ fn check_unnecessary_braces_in_use_statement(file: &SourceFileNode) -> Vec<Diagn
     let mut diagnostics = Vec::new();
     for node in file.syntax().descendants() {
         if let Some(use_tree_list) = ast::UseTreeList::cast(node) {
-            if use_tree_list.use_trees().count() <= 1 {
+            if use_tree_list.use_trees().count() == 1 {
+                let range = use_tree_list.syntax().range();
+                // use_tree_list always has one child, so we use unwrap directly here.
+                let single_use_tree: ast::UseTree = use_tree_list.use_trees().next().unwrap();
+                let edit = text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
+                    single_use_tree,
+                )
+                .unwrap_or_else(|| {
+                    let to_replace = single_use_tree.syntax().text().to_string();
+                    let mut edit_builder = TextEditBuilder::new();
+                    edit_builder.delete(range);
+                    edit_builder.insert(range.start(), to_replace);
+                    edit_builder.finish()
+                });
+
                 diagnostics.push(Diagnostic {
-                    range: use_tree_list.syntax().range(),
+                    range: range,
                     msg: format!("Unnecessary braces in use statement"),
                     severity: Severity::WeakWarning,
+                    fix: Some(LocalEdit {
+                        label: "Remove unnecessary braces".to_string(),
+                        edit: edit,
+                        cursor_position: None,
+                    }),
                 })
             }
         }
@@ -137,6 +158,28 @@ fn check_unnecessary_braces_in_use_statement(file: &SourceFileNode) -> Vec<Diagn
     diagnostics
 }
 
+fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
+    single_use_tree: ast::UseTree,
+) -> Option<TextEdit> {
+    let use_tree_list_node = single_use_tree.syntax().parent()?;
+    if single_use_tree
+        .path()?
+        .segment()?
+        .syntax()
+        .first_child()?
+        .kind()
+        == SyntaxKind::SELF_KW
+    {
+        let start = use_tree_list_node.prev_sibling()?.range().start();
+        let end = use_tree_list_node.range().end();
+        let range = TextRange::from_to(start, end);
+        let mut edit_builder = TextEditBuilder::new();
+        edit_builder.delete(range);
+        return Some(edit_builder.finish());
+    }
+    None
+}
+
 pub fn syntax_tree(file: &SourceFileNode) -> String {
     ::ra_syntax::utils::dump_tree(file.syntax())
 }
@@ -173,8 +216,9 @@ pub fn find_node_at_offset<'a, N: AstNode<'a>>(
 
 #[cfg(test)]
 mod tests {
+    use crate::test_utils::{add_cursor, assert_eq_dbg, assert_eq_text, extract_offset};
+
     use super::*;
-    use crate::test_utils::{add_cursor, assert_eq_dbg, extract_offset, assert_eq_text};
 
     #[test]
     fn test_highlighting() {
@@ -243,6 +287,7 @@ fn test_foo() {}
 use a;
 use {b};
 use a::{c};
+use a::{self};
 use a::{c, d::e};
 use a::{c, d::{e}};
 fn main() {}
@@ -250,9 +295,10 @@ fn main() {}
         );
         let diagnostics = check_unnecessary_braces_in_use_statement(&file);
         assert_eq_dbg(
-            r#"[Diagnostic { range: [12; 15), msg: "Unnecessary braces in use statement", severity: WeakWarning },
-                Diagnostic { range: [24; 27), msg: "Unnecessary braces in use statement", severity: WeakWarning },
-                Diagnostic { range: [61; 64), msg: "Unnecessary braces in use statement", severity: WeakWarning }]"#,
+            r#"[Diagnostic { range: [12; 15), msg: "Unnecessary braces in use statement", severity: WeakWarning, fix: Some(LocalEdit { label: "Remove unnecessary braces", edit: TextEdit { atoms: [AtomTextEdit { delete: [12; 12), insert: "b" }, AtomTextEdit { delete: [12; 15), insert: "" }] }, cursor_position: None }) },
+            Diagnostic { range: [24; 27), msg: "Unnecessary braces in use statement", severity: WeakWarning, fix: Some(LocalEdit { label: "Remove unnecessary braces", edit: TextEdit { atoms: [AtomTextEdit { delete: [24; 24), insert: "c" }, AtomTextEdit { delete: [24; 27), insert: "" }] }, cursor_position: None }) },
+            Diagnostic { range: [36; 42), msg: "Unnecessary braces in use statement", severity: WeakWarning, fix: Some(LocalEdit { label: "Remove unnecessary braces", edit: TextEdit { atoms: [AtomTextEdit { delete: [34; 42), insert: "" }] }, cursor_position: None }) },
+            Diagnostic { range: [76; 79), msg: "Unnecessary braces in use statement", severity: WeakWarning, fix: Some(LocalEdit { label: "Remove unnecessary braces", edit: TextEdit { atoms: [AtomTextEdit { delete: [76; 76), insert: "e" }, AtomTextEdit { delete: [76; 79), insert: "" }] }, cursor_position: None }) }]"#,
             &diagnostics,
         )
     }
diff --git a/crates/ra_editor/src/typing.rs b/crates/ra_editor/src/typing.rs
index 5e412bcfa..f0d8dc7bb 100644
--- a/crates/ra_editor/src/typing.rs
+++ b/crates/ra_editor/src/typing.rs
@@ -8,7 +8,9 @@ use ra_syntax::{
     SyntaxKind::*,
     SyntaxNodeRef, TextRange, TextUnit,
 };
-use ra_text_edit::text_utils::contains_offset_nonstrict;
+use ra_text_edit::text_utils::{
+    contains_offset_nonstrict
+};
 
 use crate::{find_node_at_offset, TextEditBuilder, LocalEdit};
 
@@ -19,6 +21,7 @@ pub fn join_lines(file: &SourceFileNode, range: TextRange) -> LocalEdit {
         let pos = match text.find('\n') {
             None => {
                 return LocalEdit {
+                    label: "join lines".to_string(),
                     edit: TextEditBuilder::new().finish(),
                     cursor_position: None,
                 };
@@ -51,6 +54,7 @@ pub fn join_lines(file: &SourceFileNode, range: TextRange) -> LocalEdit {
     }
 
     LocalEdit {
+        label: "join lines".to_string(),
         edit: edit.finish(),
         cursor_position: None,
     }
@@ -76,6 +80,7 @@ pub fn on_enter(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit> {
     let mut edit = TextEditBuilder::new();
     edit.insert(offset, inserted);
     Some(LocalEdit {
+        label: "on enter".to_string(),
         edit: edit.finish(),
         cursor_position: Some(cursor_position),
     })
@@ -126,6 +131,7 @@ pub fn on_eq_typed(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit>
     let mut edit = TextEditBuilder::new();
     edit.insert(offset, ";".to_string());
     Some(LocalEdit {
+        label: "add semicolon".to_string(),
         edit: edit.finish(),
         cursor_position: None,
     })
@@ -249,23 +255,12 @@ fn join_single_use_tree(edit: &mut TextEditBuilder, node: SyntaxNodeRef) -> Opti
 }
 
 fn single_use_tree(tree_list: ast::UseTreeList) -> Option<ast::UseTree> {
-    let mut res = None;
-    for child in tree_list.syntax().children() {
-        if let Some(tree) = ast::UseTree::cast(child) {
-            if tree.syntax().text().contains('\n') {
-                return None;
-            }
-            if mem::replace(&mut res, Some(tree)).is_some() {
-                return None;
-            }
-        } else {
-            match child.kind() {
-                WHITESPACE | L_CURLY | R_CURLY | COMMA => (),
-                _ => return None,
-            }
-        }
+    let sub_use_trees = tree_list.use_trees().count();
+    if sub_use_trees != 1 {
+        return None;
     }
-    res
+
+    tree_list.use_trees().next()
 }
 
 fn compute_ws(left: SyntaxNodeRef, right: SyntaxNodeRef) -> &'static str {
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 60f13267c..1edb9fae4 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -427,7 +427,7 @@ impl<'a> PoolDispatcher<'a> {
                                     RawResponse::err(
                                         id,
                                         ErrorCode::ContentModified as i32,
-                                        format!("content modified: {}", e),
+                                        format!("content modified: {:?}", e),
                                     )
                                 } else {
                                     RawResponse::err(
diff --git a/crates/ra_lsp_server/tests/heavy_tests/main.rs b/crates/ra_lsp_server/tests/heavy_tests/main.rs
index 029a55d40..1f5cc5e8b 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/main.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/main.rs
@@ -141,7 +141,7 @@ fn main() {}
     server.request::<CodeActionRequest>(
         CodeActionParams {
             text_document: server.doc_id("src/lib.rs"),
-            range: Range::new(Position::new(0, 0), Position::new(0, 7)),
+            range: Range::new(Position::new(0, 4), Position::new(0, 7)),
             context: empty_context(),
         },
         json!([
@@ -168,7 +168,7 @@ fn main() {}
     server.request::<CodeActionRequest>(
         CodeActionParams {
             text_document: server.doc_id("src/lib.rs"),
-            range: Range::new(Position::new(2, 0), Position::new(2, 7)),
+            range: Range::new(Position::new(2, 4), Position::new(2, 7)),
             context: empty_context(),
         },
         json!([]),
diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs
index 2795afe0b..6f96b8120 100644
--- a/crates/tools/src/lib.rs
+++ b/crates/tools/src/lib.rs
@@ -29,7 +29,7 @@ pub fn collect_tests(s: &str) -> Vec<(usize, Test)> {
     let prefix = "// ";
     let comment_blocks = s
         .lines()
-        .map(str::trim_left)
+        .map(str::trim_start)
         .enumerate()
         .group_by(|(_idx, line)| line.starts_with(prefix));