Remove dead code for handling cursor positions

crates/ra_assists/src/tests.rs

@@ -7,8 +7,7 @@ use ra_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
 use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
 use ra_syntax::TextRange;
 use test_utils::{
-    add_cursor, assert_eq_text, extract_offset, extract_range, extract_range_or_offset,
+    assert_eq_text, extract_offset, extract_range, extract_range_or_offset, RangeOrOffset,
-    RangeOrOffset,
 };
 
 use crate::{handlers::Handler, Assist, AssistConfig, AssistContext, Assists};
@@ -103,12 +102,6 @@ fn check(handler: Handler, before: &str, expected: ExpectedResult) {
 
             let mut actual = db.file_text(change.file_id).as_ref().to_owned();
             change.edit.apply(&mut actual);
-
-            if !source_change.is_snippet {
-                if let Some(off) = source_change.cursor_position {
-                    actual = add_cursor(&actual, off.offset)
-                }
-            }
             assert_eq_text!(after, &actual);
         }
         (Some(assist), ExpectedResult::Target(target)) => {

crates/ra_ide/src/diagnostics.rs

@@ -628,7 +628,6 @@ mod tests {
                                 path: "foo.rs",
                             },
                         ],
-                        cursor_position: None,
                         is_snippet: false,
                     },
                 ),
@@ -685,7 +684,6 @@ mod tests {
                             },
                         ],
                         file_system_edits: [],
-                        cursor_position: None,
                         is_snippet: false,
                     },
                 ),

crates/ra_ide/src/lib.rs

@@ -87,7 +87,6 @@ pub use ra_db::{
 pub use ra_ide_db::{
     change::{AnalysisChange, LibraryData},
     line_index::{LineCol, LineIndex},
-    line_index_utils::translate_offset_with_edit,
     search::SearchScope,
     source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
     symbol_index::Query,

crates/ra_ide/src/references/rename.rs

@@ -669,7 +669,6 @@ mod tests {
                             dst_path: "bar/foo2.rs",
                         },
                     ],
-                    cursor_position: None,
                     is_snippet: false,
                 },
             },
@@ -722,7 +721,6 @@ mod tests {
                             dst_path: "foo2/mod.rs",
                         },
                     ],
-                    cursor_position: None,
                     is_snippet: false,
                 },
             },
@@ -819,7 +817,6 @@ mod tests {
                             dst_path: "bar/foo2.rs",
                         },
                     ],
-                    cursor_position: None,
                     is_snippet: false,
                 },
             },

crates/ra_ide_db/src/lib.rs

@@ -3,7 +3,6 @@
 //! It is mainly a `HirDatabase` for semantic analysis, plus a `SymbolsDatabase`, for fuzzy search.
 
 pub mod line_index;
-pub mod line_index_utils;
 pub mod symbol_index;
 pub mod change;
 pub mod defs;

crates/ra_ide_db/src/line_index_utils.rs

@@ -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::{Indel, 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 [Indel],
-    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_indels(), 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);
-    }
-}

crates/ra_ide_db/src/source_change.rs

@@ -3,7 +3,7 @@
 //!
 //! It can be viewed as a dual for `AnalysisChange`.
 
-use ra_db::{FileId, FilePosition, RelativePathBuf, SourceRootId};
+use ra_db::{FileId, RelativePathBuf, SourceRootId};
 use ra_text_edit::TextEdit;
 
 #[derive(Debug, Clone)]
@@ -12,7 +12,6 @@ pub struct SourceChange {
     pub label: String,
     pub source_file_edits: Vec<SourceFileEdit>,
     pub file_system_edits: Vec<FileSystemEdit>,
-    pub cursor_position: Option<FilePosition>,
     pub is_snippet: bool,
 }
 
@@ -28,7 +27,6 @@ impl SourceChange {
             label: label.into(),
             source_file_edits,
             file_system_edits,
-            cursor_position: None,
             is_snippet: false,
         }
     }
@@ -42,7 +40,6 @@ impl SourceChange {
             label: label,
             source_file_edits: edits,
             file_system_edits: vec![],
-            cursor_position: None,
             is_snippet: false,
         }
     }
@@ -54,7 +51,6 @@ impl SourceChange {
             label: label.into(),
             source_file_edits: vec![],
             file_system_edits: edits,
-            cursor_position: None,
             is_snippet: false,
         }
     }
@@ -80,18 +76,6 @@ impl SourceChange {
     pub fn file_system_edit<L: Into<String>>(label: L, edit: FileSystemEdit) -> Self {
         SourceChange::file_system_edits(label, vec![edit])
     }
-
-    /// Sets the cursor position to the given `FilePosition`
-    pub fn with_cursor(mut self, cursor_position: FilePosition) -> Self {
-        self.cursor_position = Some(cursor_position);
-        self
-    }
-
-    /// Sets the cursor position to the given `FilePosition`
-    pub fn with_cursor_opt(mut self, cursor_position: Option<FilePosition>) -> Self {
-        self.cursor_position = cursor_position;
-        self
-    }
 }
 
 #[derive(Debug, Clone)]
@@ -117,7 +101,6 @@ impl SingleFileChange {
             label: self.label,
             source_file_edits: vec![SourceFileEdit { file_id, edit: self.edit }],
             file_system_edits: Vec::new(),
-            cursor_position: None,
             is_snippet: false,
         }
     }

crates/rust-analyzer/src/to_proto.rs

@@ -1,10 +1,10 @@
 //! Conversion of rust-analyzer specific types to lsp_types equivalents.
 use ra_db::{FileId, FileRange};
 use ra_ide::{
-    translate_offset_with_edit, Assist, CompletionItem, CompletionItemKind, Documentation,
+    Assist, CompletionItem, CompletionItemKind, Documentation, FileSystemEdit, Fold, FoldKind,
-    FileSystemEdit, Fold, FoldKind, FunctionSignature, Highlight, HighlightModifier, HighlightTag,
+    FunctionSignature, Highlight, HighlightModifier, HighlightTag, HighlightedRange, InlayHint,
-    HighlightedRange, InlayHint, InlayKind, InsertTextFormat, LineIndex, NavigationTarget,
+    InlayKind, InsertTextFormat, LineIndex, NavigationTarget, ReferenceAccess, Severity,
-    ReferenceAccess, Severity, SourceChange, SourceFileEdit,
+    SourceChange, SourceFileEdit,
 };
 use ra_syntax::{SyntaxKind, TextRange, TextSize};
 use ra_text_edit::{Indel, TextEdit};
@@ -375,14 +375,6 @@ pub(crate) fn url(world: &WorldSnapshot, file_id: FileId) -> Result<lsp_types::U
     world.file_id_to_uri(file_id)
 }
 
-pub(crate) fn text_document_identifier(
-    world: &WorldSnapshot,
-    file_id: FileId,
-) -> Result<lsp_types::TextDocumentIdentifier> {
-    let res = lsp_types::TextDocumentIdentifier { uri: url(world, file_id)? };
-    Ok(res)
-}
-
 pub(crate) fn versioned_text_document_identifier(
     world: &WorldSnapshot,
     file_id: FileId,
@@ -496,30 +488,9 @@ pub(crate) fn source_change(
     world: &WorldSnapshot,
     source_change: SourceChange,
 ) -> Result<lsp_ext::SourceChange> {
-    let cursor_position = match source_change.cursor_position {
-        None => None,
-        Some(pos) => {
-            let line_index = world.analysis().file_line_index(pos.file_id)?;
-            let edit = source_change
-                .source_file_edits
-                .iter()
-                .find(|it| it.file_id == pos.file_id)
-                .map(|it| &it.edit);
-            let line_col = match edit {
-                Some(edit) => translate_offset_with_edit(&*line_index, pos.offset, edit),
-                None => line_index.line_col(pos.offset),
-            };
-            let position =
-                lsp_types::Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16));
-            Some(lsp_types::TextDocumentPositionParams {
-                text_document: text_document_identifier(world, pos.file_id)?,
-                position,
-            })
-        }
-    };
     let label = source_change.label.clone();
     let workspace_edit = self::snippet_workspace_edit(world, source_change)?;
-    Ok(lsp_ext::SourceChange { label, workspace_edit, cursor_position })
+    Ok(lsp_ext::SourceChange { label, workspace_edit, cursor_position: None })
 }
 
 pub(crate) fn snippet_workspace_edit(
@@ -639,25 +610,11 @@ fn main() <fold>{
 }
 
 pub(crate) fn code_action(world: &WorldSnapshot, assist: Assist) -> Result<lsp_ext::CodeAction> {
-    let res = if assist.source_change.cursor_position.is_none() {
+    let res = lsp_ext::CodeAction {
-        lsp_ext::CodeAction {
+        title: assist.label,
-            title: assist.label,
+        kind: Some(String::new()),
-            kind: Some(String::new()),
+        edit: Some(snippet_workspace_edit(world, assist.source_change)?),
-            edit: Some(snippet_workspace_edit(world, assist.source_change)?),
+        command: None,
-            command: None,
-        }
-    } else {
-        assert!(!assist.source_change.is_snippet);
-        let source_change = source_change(&world, assist.source_change)?;
-        let arg = serde_json::to_value(source_change)?;
-        let title = assist.label;
-        let command = lsp_types::Command {
-            title: title.clone(),
-            command: "rust-analyzer.applySourceChange".to_string(),
-            arguments: Some(vec![arg]),
-        };
-
-        lsp_ext::CodeAction { title, kind: Some(String::new()), edit: None, command: Some(command) }
     };
     Ok(res)
 }