language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-26 20:09:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge commit 'baee6b338b' into sync-from-ra

Browse source
This commit is contained in:
Laurențiu Nicola 2023-08-07 12:03:15 +03:00
parent 0155385b57
commit aa55ce9567
139 changed files with 4248 additions and 1042 deletions
Download patch file Download diff file Expand all files Collapse all files

53
crates/ide-db/src/defs.rs
View file

@ -7,10 +7,10 @@
use arrayvec::ArrayVec;
use hir::{
Adt, AsAssocItem, AssocItem, BuiltinAttr, BuiltinType, Const, Crate, DeriveHelper, Field,
Function, GenericParam, HasVisibility, Impl, Label, Local, Macro, Module, ModuleDef, Name,
PathResolution, Semantics, Static, ToolModule, Trait, TraitAlias, TypeAlias, Variant,
Visibility,
Adt, AsAssocItem, AssocItem, BuiltinAttr, BuiltinType, Const, Crate, DeriveHelper,
ExternCrateDecl, Field, Function, GenericParam, HasVisibility, Impl, Label, Local, Macro,
Module, ModuleDef, Name, PathResolution, Semantics, Static, ToolModule, Trait, TraitAlias,
TypeAlias, Variant, Visibility,
};
use stdx::impl_from;
use syntax::{
@ -42,6 +42,7 @@ pub enum Definition {
DeriveHelper(DeriveHelper),
BuiltinAttr(BuiltinAttr),
ToolModule(ToolModule),
ExternCrateDecl(ExternCrateDecl),
}
impl Definition {
@ -73,6 +74,7 @@ impl Definition {
Definition::Local(it) => it.module(db),
Definition::GenericParam(it) => it.module(db),
Definition::Label(it) => it.module(db),
Definition::ExternCrateDecl(it) => it.module(db),
Definition::DeriveHelper(it) => it.derive().module(db),
Definition::BuiltinAttr(_) | Definition::BuiltinType(_) | Definition::ToolModule(_) => {
return None
@ -93,6 +95,7 @@ impl Definition {
Definition::TraitAlias(it) => it.visibility(db),
Definition::TypeAlias(it) => it.visibility(db),
Definition::Variant(it) => it.visibility(db),
Definition::ExternCrateDecl(it) => it.visibility(db),
Definition::BuiltinType(_) => Visibility::Public,
Definition::Macro(_) => return None,
Definition::BuiltinAttr(_)
@ -127,6 +130,7 @@ impl Definition {
Definition::BuiltinAttr(_) => return None, // FIXME
Definition::ToolModule(_) => return None, // FIXME
Definition::DeriveHelper(it) => it.name(db),
Definition::ExternCrateDecl(it) => return it.alias_or_name(db),
};
Some(name)
}
@ -196,6 +200,10 @@ impl IdentClass {
res.push(Definition::Local(local_ref));
res.push(Definition::Field(field_ref));
}
IdentClass::NameRefClass(NameRefClass::ExternCrateShorthand { decl, krate }) => {
res.push(Definition::ExternCrateDecl(decl));
res.push(Definition::Module(krate.root_module()));
}
IdentClass::Operator(
OperatorClass::Await(func)
| OperatorClass::Prefix(func)
@ -222,6 +230,10 @@ impl IdentClass {
res.push(Definition::Local(local_ref));
res.push(Definition::Field(field_ref));
}
IdentClass::NameRefClass(NameRefClass::ExternCrateShorthand { decl, krate }) => {
res.push(Definition::ExternCrateDecl(decl));
res.push(Definition::Module(krate.root_module()));
}
IdentClass::Operator(_) => (),
}
res
@ -310,6 +322,7 @@ impl NameClass {
ast::Item::Enum(it) => Definition::Adt(hir::Adt::Enum(sema.to_def(&it)?)),
ast::Item::Struct(it) => Definition::Adt(hir::Adt::Struct(sema.to_def(&it)?)),
ast::Item::Union(it) => Definition::Adt(hir::Adt::Union(sema.to_def(&it)?)),
ast::Item::ExternCrate(it) => Definition::ExternCrateDecl(sema.to_def(&it)?),
_ => return None,
};
Some(definition)
@ -346,10 +359,8 @@ impl NameClass {
let path = use_tree.path()?;
sema.resolve_path(&path).map(Definition::from)
} else {
let extern_crate = rename.syntax().parent().and_then(ast::ExternCrate::cast)?;
let krate = sema.resolve_extern_crate(&extern_crate)?;
let root_module = krate.root_module(sema.db);
Some(Definition::Module(root_module))
sema.to_def(&rename.syntax().parent().and_then(ast::ExternCrate::cast)?)
.map(Definition::ExternCrateDecl)
}
}
}
@ -427,7 +438,19 @@ impl OperatorClass {
#[derive(Debug)]
pub enum NameRefClass {
Definition(Definition),
FieldShorthand { local_ref: Local, field_ref: Field },
FieldShorthand {
local_ref: Local,
field_ref: Field,
},
/// The specific situation where we have an extern crate decl without a rename
/// Here we have both a declaration and a reference.
/// ```rs
/// extern crate foo;
/// ```
ExternCrateShorthand {
decl: ExternCrateDecl,
krate: Crate,
},
}
impl NameRefClass {
@ -513,10 +536,14 @@ impl NameRefClass {
}
None
},
ast::ExternCrate(extern_crate) => {
let krate = sema.resolve_extern_crate(&extern_crate)?;
let root_module = krate.root_module(sema.db);
Some(NameRefClass::Definition(Definition::Module(root_module)))
ast::ExternCrate(extern_crate_ast) => {
let extern_crate = sema.to_def(&extern_crate_ast)?;
let krate = extern_crate.resolved_crate(sema.db)?;
Some(if extern_crate_ast.rename().is_some() {
NameRefClass::Definition(Definition::Module(krate.root_module()))
} else {
NameRefClass::ExternCrateShorthand { krate, decl: extern_crate }
})
},
_ => None
}

2
crates/ide-db/src/famous_defs.rs
View file

@ -167,7 +167,7 @@ impl FamousDefs<'_, '_> {
lang_crate => lang_crate,
};
let std_crate = self.find_lang_crate(lang_crate)?;
let mut module = std_crate.root_module(db);
let mut module = std_crate.root_module();
for segment in path {
module = module.children(db).find_map(|child| {
let name = child.name(db)?;

18
crates/ide-db/src/rename.rs
View file

@ -82,8 +82,9 @@ impl Definition {
}
/// Textual range of the identifier which will change when renaming this
/// `Definition`. Note that some definitions, like builtin types, can't be
/// renamed.
/// `Definition`. Note that builtin types can't be
/// renamed and extern crate names will report its range, though a rename will introduce
/// an alias instead.
pub fn range_for_rename(self, sema: &Semantics<'_, RootDatabase>) -> Option<FileRange> {
let res = match self {
Definition::Macro(mac) => {
@ -146,6 +147,16 @@ impl Definition {
let lifetime = src.value.lifetime()?;
src.with_value(lifetime.syntax()).original_file_range_opt(sema.db)
}
Definition::ExternCrateDecl(it) => {
let src = it.source(sema.db)?;
if let Some(rename) = src.value.rename() {
let name = rename.name()?;
src.with_value(name.syntax()).original_file_range_opt(sema.db)
} else {
let name = src.value.name_ref()?;
src.with_value(name.syntax()).original_file_range_opt(sema.db)
}
}
Definition::BuiltinType(_) => return None,
Definition::SelfType(_) => return None,
Definition::BuiltinAttr(_) => return None,
@ -526,6 +537,9 @@ fn source_edit_from_def(
TextRange::new(range.start() + syntax::TextSize::from(1), range.end()),
new_name.strip_prefix('\'').unwrap_or(new_name).to_owned(),
),
Definition::ExternCrateDecl(decl) if decl.alias(sema.db).is_none() => {
(TextRange::empty(range.end()), format!(" as {new_name}"))
}
_ => (range, new_name.to_owned()),
};
edit.replace(range, new_name);

12
crates/ide-db/src/search.rs
View file

@ -127,7 +127,7 @@ impl SearchScope {
}
/// Build a search scope spanning the given module and all its submodules.
fn module_and_children(db: &RootDatabase, module: hir::Module) -> SearchScope {
pub fn module_and_children(db: &RootDatabase, module: hir::Module) -> SearchScope {
let mut entries = IntMap::default();
let (file_id, range) = {
@ -329,7 +329,7 @@ impl Definition {
pub struct FindUsages<'a> {
def: Definition,
sema: &'a Semantics<'a, RootDatabase>,
scope: Option<SearchScope>,
scope: Option<&'a SearchScope>,
/// The container of our definition should it be an assoc item
assoc_item_container: Option<hir::AssocItemContainer>,
/// whether to search for the `Self` type of the definition
@ -338,7 +338,7 @@ pub struct FindUsages<'a> {
search_self_mod: bool,
}
impl FindUsages<'_> {
impl<'a> FindUsages<'a> {
/// Enable searching for `Self` when the definition is a type or `self` for modules.
pub fn include_self_refs(mut self) -> Self {
self.include_self_kw_refs = def_to_ty(self.sema, &self.def);
@ -347,12 +347,12 @@ impl FindUsages<'_> {
}
/// Limit the search to a given [`SearchScope`].
pub fn in_scope(self, scope: SearchScope) -> Self {
pub fn in_scope(self, scope: &'a SearchScope) -> Self {
self.set_scope(Some(scope))
}
/// Limit the search to a given [`SearchScope`].
pub fn set_scope(mut self, scope: Option<SearchScope>) -> Self {
pub fn set_scope(mut self, scope: Option<&'a SearchScope>) -> Self {
assert!(self.scope.is_none());
self.scope = scope;
self
@ -376,7 +376,7 @@ impl FindUsages<'_> {
res
}
fn search(&self, sink: &mut dyn FnMut(FileId, FileReference) -> bool) {
pub fn search(&self, sink: &mut dyn FnMut(FileId, FileReference) -> bool) {
let _p = profile::span("FindUsages:search");
let sema = self.sema;

204
crates/ide-db/src/source_change.rs
View file

@ -7,17 +7,17 @@ use std::{collections::hash_map::Entry, iter, mem};
use crate::SnippetCap;
use base_db::{AnchoredPathBuf, FileId};
use itertools::Itertools;
use nohash_hasher::IntMap;
use stdx::never;
use syntax::{
algo, ast, ted, AstNode, SyntaxElement, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange,
TextSize,
algo, AstNode, SyntaxElement, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange, TextSize,
};
use text_edit::{TextEdit, TextEditBuilder};
#[derive(Default, Debug, Clone)]
pub struct SourceChange {
pub source_file_edits: IntMap<FileId, TextEdit>,
pub source_file_edits: IntMap<FileId, (TextEdit, Option<SnippetEdit>)>,
pub file_system_edits: Vec<FileSystemEdit>,
pub is_snippet: bool,
}
@ -26,7 +26,7 @@ impl SourceChange {
/// Creates a new SourceChange with the given label
/// from the edits.
pub fn from_edits(
source_file_edits: IntMap<FileId, TextEdit>,
source_file_edits: IntMap<FileId, (TextEdit, Option<SnippetEdit>)>,
file_system_edits: Vec<FileSystemEdit>,
) -> Self {
SourceChange { source_file_edits, file_system_edits, is_snippet: false }
@ -34,7 +34,7 @@ impl SourceChange {
pub fn from_text_edit(file_id: FileId, edit: TextEdit) -> Self {
SourceChange {
source_file_edits: iter::once((file_id, edit)).collect(),
source_file_edits: iter::once((file_id, (edit, None))).collect(),
..Default::default()
}
}
@ -42,12 +42,31 @@ impl SourceChange {
/// Inserts a [`TextEdit`] for the given [`FileId`]. This properly handles merging existing
/// edits for a file if some already exist.
pub fn insert_source_edit(&mut self, file_id: FileId, edit: TextEdit) {
self.insert_source_and_snippet_edit(file_id, edit, None)
}
/// Inserts a [`TextEdit`] and potentially a [`SnippetEdit`] for the given [`FileId`].
/// This properly handles merging existing edits for a file if some already exist.
pub fn insert_source_and_snippet_edit(
&mut self,
file_id: FileId,
edit: TextEdit,
snippet_edit: Option<SnippetEdit>,
) {
match self.source_file_edits.entry(file_id) {
Entry::Occupied(mut entry) => {
never!(entry.get_mut().union(edit).is_err(), "overlapping edits for same file");
let value = entry.get_mut();
never!(value.0.union(edit).is_err(), "overlapping edits for same file");
never!(
value.1.is_some() && snippet_edit.is_some(),
"overlapping snippet edits for same file"
);
if value.1.is_none() {
value.1 = snippet_edit;
}
}
Entry::Vacant(entry) => {
entry.insert(edit);
entry.insert((edit, snippet_edit));
}
}
}
@ -56,7 +75,10 @@ impl SourceChange {
self.file_system_edits.push(edit);
}
pub fn get_source_edit(&self, file_id: FileId) -> Option<&TextEdit> {
pub fn get_source_and_snippet_edit(
&self,
file_id: FileId,
) -> Option<&(TextEdit, Option<SnippetEdit>)> {
self.source_file_edits.get(&file_id)
}
@ -70,7 +92,18 @@ impl SourceChange {
impl Extend<(FileId, TextEdit)> for SourceChange {
fn extend<T: IntoIterator<Item = (FileId, TextEdit)>>(&mut self, iter: T) {
iter.into_iter().for_each(|(file_id, edit)| self.insert_source_edit(file_id, edit));
self.extend(iter.into_iter().map(|(file_id, edit)| (file_id, (edit, None))))
}
}
impl Extend<(FileId, (TextEdit, Option<SnippetEdit>))> for SourceChange {
fn extend<T: IntoIterator<Item = (FileId, (TextEdit, Option<SnippetEdit>))>>(
&mut self,
iter: T,
) {
iter.into_iter().for_each(|(file_id, (edit, snippet_edit))| {
self.insert_source_and_snippet_edit(file_id, edit, snippet_edit)
});
}
}
@ -82,6 +115,8 @@ impl Extend<FileSystemEdit> for SourceChange {
impl From<IntMap<FileId, TextEdit>> for SourceChange {
fn from(source_file_edits: IntMap<FileId, TextEdit>) -> SourceChange {
let source_file_edits =
source_file_edits.into_iter().map(|(file_id, edit)| (file_id, (edit, None))).collect();
SourceChange { source_file_edits, file_system_edits: Vec::new(), is_snippet: false }
}
}
@ -94,6 +129,65 @@ impl FromIterator<(FileId, TextEdit)> for SourceChange {
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SnippetEdit(Vec<(u32, TextRange)>);
impl SnippetEdit {
pub fn new(snippets: Vec<Snippet>) -> Self {
let mut snippet_ranges = snippets
.into_iter()
.zip(1..)
.with_position()
.map(|pos| {
let (snippet, index) = match pos {
itertools::Position::First(it) | itertools::Position::Middle(it) => it,
// last/only snippet gets index 0
itertools::Position::Last((snippet, _))
| itertools::Position::Only((snippet, _)) => (snippet, 0),
};
let range = match snippet {
Snippet::Tabstop(pos) => TextRange::empty(pos),
Snippet::Placeholder(range) => range,
};
(index, range)
})
.collect_vec();
snippet_ranges.sort_by_key(|(_, range)| range.start());
// Ensure that none of the ranges overlap
let disjoint_ranges = snippet_ranges
.iter()
.zip(snippet_ranges.iter().skip(1))
.all(|((_, left), (_, right))| left.end() <= right.start() || left == right);
stdx::always!(disjoint_ranges);
SnippetEdit(snippet_ranges)
}
/// Inserts all of the snippets into the given text.
pub fn apply(&self, text: &mut String) {
// Start from the back so that we don't have to adjust ranges
for (index, range) in self.0.iter().rev() {
if range.is_empty() {
// is a tabstop
text.insert_str(range.start().into(), &format!("${index}"));
} else {
// is a placeholder
text.insert(range.end().into(), '}');
text.insert_str(range.start().into(), &format!("${{{index}:"));
}
}
}
/// Gets the underlying snippet index + text range
/// Tabstops are represented by an empty range, and placeholders use the range that they were given
pub fn into_edit_ranges(self) -> Vec<(u32, TextRange)> {
self.0
}
}
pub struct SourceChangeBuilder {
pub edit: TextEditBuilder,
pub file_id: FileId,
@ -152,24 +246,19 @@ impl SourceChangeBuilder {
}
fn commit(&mut self) {
// Render snippets first so that they get bundled into the tree diff
if let Some(mut snippets) = self.snippet_builder.take() {
// Last snippet always has stop index 0
let last_stop = snippets.places.pop().unwrap();
last_stop.place(0);
for (index, stop) in snippets.places.into_iter().enumerate() {
stop.place(index + 1)
}
}
let snippet_edit = self.snippet_builder.take().map(|builder| {
SnippetEdit::new(
builder.places.into_iter().map(PlaceSnippet::finalize_position).collect_vec(),
)
});
if let Some(tm) = self.mutated_tree.take() {
algo::diff(&tm.immutable, &tm.mutable_clone).into_text_edit(&mut self.edit)
algo::diff(&tm.immutable, &tm.mutable_clone).into_text_edit(&mut self.edit);
}
let edit = mem::take(&mut self.edit).finish();
if !edit.is_empty() {
self.source_change.insert_source_edit(self.file_id, edit);
if !edit.is_empty() || snippet_edit.is_some() {
self.source_change.insert_source_and_snippet_edit(self.file_id, edit, snippet_edit);
}
}
@ -275,6 +364,16 @@ impl SourceChangeBuilder {
pub fn finish(mut self) -> SourceChange {
self.commit();
// Only one file can have snippet edits
stdx::never!(self
.source_change
.source_file_edits
.iter()
.filter(|(_, (_, snippet_edit))| snippet_edit.is_some())
.at_most_one()
.is_err());
mem::take(&mut self.source_change)
}
}
@ -296,6 +395,13 @@ impl From<FileSystemEdit> for SourceChange {
}
}
pub enum Snippet {
/// A tabstop snippet (e.g. `$0`).
Tabstop(TextSize),
/// A placeholder snippet (e.g. `${0:placeholder}`).
Placeholder(TextRange),
}
enum PlaceSnippet {
/// Place a tabstop before an element
Before(SyntaxElement),
@ -306,57 +412,11 @@ enum PlaceSnippet {
}
impl PlaceSnippet {
/// Places the snippet before or over an element with the given tab stop index
fn place(self, order: usize) {
// ensure the target element is still attached
match &self {
PlaceSnippet::Before(element)
| PlaceSnippet::After(element)
| PlaceSnippet::Over(element) => {
// element should still be in the tree, but if it isn't
// then it's okay to just ignore this place
if stdx::never!(element.parent().is_none()) {
return;
}
}
}
fn finalize_position(self) -> Snippet {
match self {
PlaceSnippet::Before(element) => {
ted::insert_raw(ted::Position::before(&element), Self::make_tab_stop(order));
}
PlaceSnippet::After(element) => {
ted::insert_raw(ted::Position::after(&element), Self::make_tab_stop(order));
}
PlaceSnippet::Over(element) => {
let position = ted::Position::before(&element);
element.detach();
let snippet = ast::SourceFile::parse(&format!("${{{order}:_}}"))
.syntax_node()
.clone_for_update();
let placeholder =
snippet.descendants().find_map(ast::UnderscoreExpr::cast).unwrap();
ted::replace(placeholder.syntax(), element);
ted::insert_raw(position, snippet);
}
PlaceSnippet::Before(it) => Snippet::Tabstop(it.text_range().start()),
PlaceSnippet::After(it) => Snippet::Tabstop(it.text_range().end()),
PlaceSnippet::Over(it) => Snippet::Placeholder(it.text_range()),
}
}
fn make_tab_stop(order: usize) -> SyntaxNode {
let stop = ast::SourceFile::parse(&format!("stop!(${order})"))
.syntax_node()
.descendants()
.find_map(ast::TokenTree::cast)
.unwrap()
.syntax()
.clone_for_update();
stop.first_token().unwrap().detach();
stop.last_token().unwrap().detach();
stop
}
}