+++ /dev/null
-//! 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);
- }
-}
//!
//! 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)]
pub label: String,
pub source_file_edits: Vec<SourceFileEdit>,
pub file_system_edits: Vec<FileSystemEdit>,
- pub cursor_position: Option<FilePosition>,
pub is_snippet: bool,
}
label: label.into(),
source_file_edits,
file_system_edits,
- cursor_position: None,
is_snippet: false,
}
}
label: label,
source_file_edits: edits,
file_system_edits: vec![],
- cursor_position: None,
is_snippet: false,
}
}
label: label.into(),
source_file_edits: vec![],
file_system_edits: edits,
- cursor_position: None,
is_snippet: false,
}
}
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)]
label: self.label,
source_file_edits: vec![SourceFileEdit { file_id, edit: self.edit }],
file_system_edits: Vec::new(),
- cursor_position: None,
is_snippet: false,
}
}
//! 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,
- FileSystemEdit, Fold, FoldKind, FunctionSignature, Highlight, HighlightModifier, HighlightTag,
- HighlightedRange, InlayHint, InlayKind, InsertTextFormat, LineIndex, NavigationTarget,
- ReferenceAccess, Severity, SourceChange, SourceFileEdit,
+ Assist, CompletionItem, CompletionItemKind, Documentation, FileSystemEdit, Fold, FoldKind,
+ FunctionSignature, Highlight, HighlightModifier, HighlightTag, HighlightedRange, InlayHint,
+ InlayKind, InsertTextFormat, LineIndex, NavigationTarget, ReferenceAccess, Severity,
+ SourceChange, SourceFileEdit,
};
use ra_syntax::{SyntaxKind, TextRange, TextSize};
use ra_text_edit::{Indel, TextEdit};
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,
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(
}
pub(crate) fn code_action(world: &WorldSnapshot, assist: Assist) -> Result<lsp_ext::CodeAction> {
- let res = if assist.source_change.cursor_position.is_none() {
- lsp_ext::CodeAction {
- title: assist.label,
- kind: Some(String::new()),
- edit: Some(snippet_workspace_edit(world, assist.source_change)?),
- 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) }
+ let res = lsp_ext::CodeAction {
+ title: assist.label,
+ kind: Some(String::new()),
+ edit: Some(snippet_workspace_edit(world, assist.source_change)?),
+ command: None,
};
Ok(res)
}
projects / rust.git / commitdiff