2021-05-22 08:53:47 -05:00
|
|
|
//! See [`AssistContext`].
|
2020-05-06 11:45:35 -05:00
|
|
|
|
2020-02-18 11:35:10 -06:00
|
|
|
use hir::Semantics;
|
2022-08-06 09:51:51 -05:00
|
|
|
use ide_db::base_db::{FileId, FileRange};
|
|
|
|
use ide_db::{label::Label, RootDatabase};
|
2020-08-12 11:26:51 -05:00
|
|
|
use syntax::{
|
2021-05-08 06:38:56 -05:00
|
|
|
algo::{self, find_node_at_offset, find_node_at_range},
|
2022-08-06 09:51:51 -05:00
|
|
|
AstNode, AstToken, Direction, SourceFile, SyntaxElement, SyntaxKind, SyntaxToken, TextRange,
|
|
|
|
TextSize, TokenAtOffset,
|
2019-02-03 12:26:35 -06:00
|
|
|
};
|
|
|
|
|
2021-05-03 09:08:09 -05:00
|
|
|
use crate::{
|
|
|
|
assist_config::AssistConfig, Assist, AssistId, AssistKind, AssistResolveStrategy, GroupLabel,
|
|
|
|
};
|
2019-02-03 12:26:35 -06:00
|
|
|
|
2022-08-06 09:51:51 -05:00
|
|
|
pub(crate) use ide_db::source_change::{SourceChangeBuilder, TreeMutator};
|
|
|
|
|
2020-05-06 11:45:35 -05:00
|
|
|
/// `AssistContext` allows to apply an assist or check if it could be applied.
|
2019-02-03 12:26:35 -06:00
|
|
|
///
|
2020-05-06 11:45:35 -05:00
|
|
|
/// Assists use a somewhat over-engineered approach, given the current needs.
|
|
|
|
/// The assists workflow consists of two phases. In the first phase, a user asks
|
|
|
|
/// for the list of available assists. In the second phase, the user picks a
|
2019-02-03 12:26:35 -06:00
|
|
|
/// particular assist and it gets applied.
|
|
|
|
///
|
|
|
|
/// There are two peculiarities here:
|
|
|
|
///
|
2020-05-06 11:45:35 -05:00
|
|
|
/// * first, we ideally avoid computing more things then necessary to answer "is
|
|
|
|
/// assist applicable" in the first phase.
|
2019-02-03 12:26:35 -06:00
|
|
|
/// * second, when we are applying assist, we don't have a guarantee that there
|
|
|
|
/// weren't any changes between the point when user asked for assists and when
|
|
|
|
/// they applied a particular assist. So, when applying assist, we need to do
|
|
|
|
/// all the checks from scratch.
|
|
|
|
///
|
|
|
|
/// To avoid repeating the same code twice for both "check" and "apply"
|
|
|
|
/// functions, we use an approach reminiscent of that of Django's function based
|
|
|
|
/// views dealing with forms. Each assist receives a runtime parameter,
|
2020-05-06 11:45:35 -05:00
|
|
|
/// `resolve`. It first check if an edit is applicable (potentially computing
|
|
|
|
/// info required to compute the actual edit). If it is applicable, and
|
|
|
|
/// `resolve` is `true`, it then computes the actual edit.
|
2019-02-03 12:26:35 -06:00
|
|
|
///
|
|
|
|
/// So, to implement the original assists workflow, we can first apply each edit
|
2020-05-06 11:45:35 -05:00
|
|
|
/// with `resolve = false`, and then applying the selected edit again, with
|
|
|
|
/// `resolve = true` this time.
|
2019-02-03 12:26:35 -06:00
|
|
|
///
|
|
|
|
/// Note, however, that we don't actually use such two-phase logic at the
|
|
|
|
/// moment, because the LSP API is pretty awkward in this place, and it's much
|
2019-12-24 09:44:32 -06:00
|
|
|
/// easier to just compute the edit eagerly :-)
|
2020-05-06 11:45:35 -05:00
|
|
|
pub(crate) struct AssistContext<'a> {
|
2020-05-17 05:09:53 -05:00
|
|
|
pub(crate) config: &'a AssistConfig,
|
2020-05-06 11:45:35 -05:00
|
|
|
pub(crate) sema: Semantics<'a, RootDatabase>,
|
2021-10-13 07:39:37 -05:00
|
|
|
frange: FileRange,
|
2021-10-12 07:41:59 -05:00
|
|
|
trimmed_range: TextRange,
|
2019-07-19 03:24:41 -05:00
|
|
|
source_file: SourceFile,
|
2019-02-03 12:26:35 -06:00
|
|
|
}
|
|
|
|
|
2020-05-06 11:45:35 -05:00
|
|
|
impl<'a> AssistContext<'a> {
|
2020-05-17 05:09:53 -05:00
|
|
|
pub(crate) fn new(
|
|
|
|
sema: Semantics<'a, RootDatabase>,
|
|
|
|
config: &'a AssistConfig,
|
|
|
|
frange: FileRange,
|
|
|
|
) -> AssistContext<'a> {
|
2020-02-18 11:35:10 -06:00
|
|
|
let source_file = sema.parse(frange.file_id);
|
2021-10-12 07:41:59 -05:00
|
|
|
|
|
|
|
let start = frange.range.start();
|
|
|
|
let end = frange.range.end();
|
|
|
|
let left = source_file.syntax().token_at_offset(start);
|
|
|
|
let right = source_file.syntax().token_at_offset(end);
|
|
|
|
let left =
|
|
|
|
left.right_biased().and_then(|t| algo::skip_whitespace_token(t, Direction::Next));
|
|
|
|
let right =
|
|
|
|
right.left_biased().and_then(|t| algo::skip_whitespace_token(t, Direction::Prev));
|
2021-10-12 14:29:08 -05:00
|
|
|
let left = left.map(|t| t.text_range().start().clamp(start, end));
|
|
|
|
let right = right.map(|t| t.text_range().end().clamp(start, end));
|
|
|
|
|
|
|
|
let trimmed_range = match (left, right) {
|
|
|
|
(Some(left), Some(right)) if left <= right => TextRange::new(left, right),
|
|
|
|
// Selection solely consists of whitespace so just fall back to the original
|
|
|
|
_ => frange.range,
|
|
|
|
};
|
2021-10-12 07:41:59 -05:00
|
|
|
|
|
|
|
AssistContext { config, sema, frange, source_file, trimmed_range }
|
2020-07-01 02:14:23 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn db(&self) -> &RootDatabase {
|
|
|
|
self.sema.db
|
2019-02-03 12:26:35 -06:00
|
|
|
}
|
|
|
|
|
2020-05-06 11:45:35 -05:00
|
|
|
// NB, this ignores active selection.
|
|
|
|
pub(crate) fn offset(&self) -> TextSize {
|
|
|
|
self.frange.range.start()
|
2019-02-03 12:26:35 -06:00
|
|
|
}
|
|
|
|
|
2021-10-13 07:39:37 -05:00
|
|
|
pub(crate) fn file_id(&self) -> FileId {
|
|
|
|
self.frange.file_id
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn has_empty_selection(&self) -> bool {
|
|
|
|
self.trimmed_range.is_empty()
|
|
|
|
}
|
|
|
|
|
2021-10-12 07:41:59 -05:00
|
|
|
/// Returns the selected range trimmed for whitespace tokens, that is the range will be snapped
|
|
|
|
/// to the nearest enclosed token.
|
|
|
|
pub(crate) fn selection_trimmed(&self) -> TextRange {
|
|
|
|
self.trimmed_range
|
|
|
|
}
|
|
|
|
|
2019-07-19 03:24:41 -05:00
|
|
|
pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> {
|
2020-05-06 11:45:35 -05:00
|
|
|
self.source_file.syntax().token_at_offset(self.offset())
|
2019-02-03 12:26:35 -06:00
|
|
|
}
|
2020-11-06 15:21:56 -06:00
|
|
|
pub(crate) fn find_token_syntax_at_offset(&self, kind: SyntaxKind) -> Option<SyntaxToken> {
|
2019-10-27 03:45:59 -05:00
|
|
|
self.token_at_offset().find(|it| it.kind() == kind)
|
|
|
|
}
|
2020-11-06 15:21:56 -06:00
|
|
|
pub(crate) fn find_token_at_offset<T: AstToken>(&self) -> Option<T> {
|
|
|
|
self.token_at_offset().find_map(T::cast)
|
|
|
|
}
|
2019-10-27 03:48:40 -05:00
|
|
|
pub(crate) fn find_node_at_offset<N: AstNode>(&self) -> Option<N> {
|
2020-05-06 11:45:35 -05:00
|
|
|
find_node_at_offset(self.source_file.syntax(), self.offset())
|
2019-02-03 12:26:35 -06:00
|
|
|
}
|
2021-03-29 06:17:49 -05:00
|
|
|
pub(crate) fn find_node_at_range<N: AstNode>(&self) -> Option<N> {
|
2021-10-12 07:41:59 -05:00
|
|
|
find_node_at_range(self.source_file.syntax(), self.trimmed_range)
|
2021-03-29 06:17:49 -05:00
|
|
|
}
|
2020-05-02 14:24:55 -05:00
|
|
|
pub(crate) fn find_node_at_offset_with_descend<N: AstNode>(&self) -> Option<N> {
|
2020-05-07 10:32:01 -05:00
|
|
|
self.sema.find_node_at_offset_with_descend(self.source_file.syntax(), self.offset())
|
2020-05-02 14:24:55 -05:00
|
|
|
}
|
2021-10-12 07:41:59 -05:00
|
|
|
/// Returns the element covered by the selection range, this excludes trailing whitespace in the selection.
|
2019-07-19 03:24:41 -05:00
|
|
|
pub(crate) fn covering_element(&self) -> SyntaxElement {
|
2021-10-12 07:41:59 -05:00
|
|
|
self.source_file.syntax().covering_element(self.selection_trimmed())
|
2019-02-03 12:26:35 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-06 11:45:35 -05:00
|
|
|
pub(crate) struct Assists {
|
|
|
|
file: FileId,
|
2021-05-03 09:08:09 -05:00
|
|
|
resolve: AssistResolveStrategy,
|
2020-12-26 05:11:42 -06:00
|
|
|
buf: Vec<Assist>,
|
2020-07-13 16:41:47 -05:00
|
|
|
allowed: Option<Vec<AssistKind>>,
|
2020-02-09 07:30:27 -06:00
|
|
|
}
|
|
|
|
|
2020-05-06 11:45:35 -05:00
|
|
|
impl Assists {
|
2022-07-20 08:02:08 -05:00
|
|
|
pub(crate) fn new(ctx: &AssistContext<'_>, resolve: AssistResolveStrategy) -> Assists {
|
2020-07-13 16:41:47 -05:00
|
|
|
Assists {
|
2020-12-26 05:11:42 -06:00
|
|
|
resolve,
|
2020-07-13 16:41:47 -05:00
|
|
|
file: ctx.frange.file_id,
|
|
|
|
buf: Vec::new(),
|
2020-07-15 08:45:30 -05:00
|
|
|
allowed: ctx.config.allowed.clone(),
|
2020-07-13 16:41:47 -05:00
|
|
|
}
|
2020-05-06 11:45:35 -05:00
|
|
|
}
|
2020-07-13 16:41:47 -05:00
|
|
|
|
2020-12-26 05:11:42 -06:00
|
|
|
pub(crate) fn finish(mut self) -> Vec<Assist> {
|
|
|
|
self.buf.sort_by_key(|assist| assist.target.len());
|
|
|
|
self.buf
|
2020-05-06 11:45:35 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn add(
|
2020-02-09 07:30:27 -06:00
|
|
|
&mut self,
|
|
|
|
id: AssistId,
|
|
|
|
label: impl Into<String>,
|
2020-05-06 05:51:28 -05:00
|
|
|
target: TextRange,
|
2022-08-06 09:51:51 -05:00
|
|
|
f: impl FnOnce(&mut SourceChangeBuilder),
|
2020-05-06 11:45:35 -05:00
|
|
|
) -> Option<()> {
|
2021-08-29 04:31:42 -05:00
|
|
|
let mut f = Some(f);
|
|
|
|
self.add_impl(None, id, label.into(), target, &mut |it| f.take().unwrap()(it))
|
2020-05-06 11:45:35 -05:00
|
|
|
}
|
2020-07-13 16:41:47 -05:00
|
|
|
|
2020-05-06 11:45:35 -05:00
|
|
|
pub(crate) fn add_group(
|
|
|
|
&mut self,
|
|
|
|
group: &GroupLabel,
|
|
|
|
id: AssistId,
|
|
|
|
label: impl Into<String>,
|
|
|
|
target: TextRange,
|
2022-08-06 09:51:51 -05:00
|
|
|
f: impl FnOnce(&mut SourceChangeBuilder),
|
2021-08-29 04:31:42 -05:00
|
|
|
) -> Option<()> {
|
|
|
|
let mut f = Some(f);
|
|
|
|
self.add_impl(Some(group), id, label.into(), target, &mut |it| f.take().unwrap()(it))
|
|
|
|
}
|
|
|
|
|
|
|
|
fn add_impl(
|
|
|
|
&mut self,
|
|
|
|
group: Option<&GroupLabel>,
|
|
|
|
id: AssistId,
|
|
|
|
label: String,
|
|
|
|
target: TextRange,
|
2022-08-06 09:51:51 -05:00
|
|
|
f: &mut dyn FnMut(&mut SourceChangeBuilder),
|
2020-05-06 11:45:35 -05:00
|
|
|
) -> Option<()> {
|
2020-07-13 16:41:47 -05:00
|
|
|
if !self.is_allowed(&id) {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
2022-04-19 11:37:18 -05:00
|
|
|
let mut trigger_signature_help = false;
|
2021-08-29 04:31:42 -05:00
|
|
|
let source_change = if self.resolve.should_resolve(&id) {
|
2022-08-06 09:51:51 -05:00
|
|
|
let mut builder = SourceChangeBuilder::new(self.file);
|
2020-05-06 11:45:35 -05:00
|
|
|
f(&mut builder);
|
2022-04-19 11:37:18 -05:00
|
|
|
trigger_signature_help = builder.trigger_signature_help;
|
2020-05-22 11:03:08 -05:00
|
|
|
Some(builder.finish())
|
2020-05-06 11:45:35 -05:00
|
|
|
} else {
|
|
|
|
None
|
2020-02-09 07:30:27 -06:00
|
|
|
};
|
|
|
|
|
2021-09-13 11:50:19 -05:00
|
|
|
let label = Label::new(label);
|
2021-08-29 04:31:42 -05:00
|
|
|
let group = group.cloned();
|
2022-04-19 11:37:18 -05:00
|
|
|
self.buf.push(Assist { id, label, group, target, source_change, trigger_signature_help });
|
2020-05-06 11:45:35 -05:00
|
|
|
Some(())
|
2020-02-09 07:30:27 -06:00
|
|
|
}
|
|
|
|
|
2020-07-13 16:41:47 -05:00
|
|
|
fn is_allowed(&self, id: &AssistId) -> bool {
|
|
|
|
match &self.allowed {
|
|
|
|
Some(allowed) => allowed.iter().any(|kind| kind.contains(id.1)),
|
|
|
|
None => true,
|
|
|
|
}
|
|
|
|
}
|
2020-02-09 07:30:27 -06:00
|
|
|
}
|