nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-26 22:05:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

internal: adapt diagnostics to the new rename API

Browse Source
This commit is contained in:
Aleksey Kladov 2021-06-14 18:46:27 +03:00
parent a91071b57b
commit 26c978f258
4 changed files with 474 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

435
crates/ide/src/references/rename.rs
View File

@ -2,44 +2,23 @@
//!
//! All reference and file rename requests go through here where the corresponding [`SourceChange`]s
//! will be calculated.
use std::fmt::{self, Display};
use either::Either;
use hir::{AsAssocItem, FieldSource, HasSource, InFile, ModuleSource, Semantics};
use hir::{AsAssocItem, InFile, Semantics};
use ide_db::{
base_db::{AnchoredPathBuf, FileId, FileRange},
base_db::FileId,
defs::{Definition, NameClass, NameRefClass},
search::FileReference,
rename::{bail, format_err, source_edit_from_references, IdentifierKind},
RootDatabase,
};
use stdx::never;
use syntax::{
ast::{self, NameOwner},
lex_single_syntax_kind, AstNode, SyntaxKind, SyntaxNode, T,
};
use syntax::{ast, AstNode, SyntaxNode};
use text_edit::TextEdit;
use crate::{FilePosition, FileSystemEdit, RangeInfo, SourceChange, TextRange};
use crate::{FilePosition, RangeInfo, SourceChange};
pub use ide_db::rename::RenameError;
type RenameResult<T> = Result<T, RenameError>;
#[derive(Debug)]
pub struct RenameError(String);
impl fmt::Display for RenameError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
Display::fmt(&self.0, f)
}
}
macro_rules! format_err {
($fmt:expr) => {RenameError(format!($fmt))};
($fmt:expr, $($arg:tt)+) => {RenameError(format!($fmt, $($arg)+))}
}
macro_rules! bail {
($($tokens:tt)*) => {return Err(format_err!($($tokens)*))}
}
/// Prepares a rename. The sole job of this function is to return the TextRange of the thing that is
/// being targeted for a rename.
@ -52,8 +31,8 @@ pub(crate) fn prepare_rename(
let syntax = source_file.syntax();
let def = find_definition(&sema, syntax, position)?;
let frange = def_name_range(&&sema, def)
.ok_or_else(|| format_err!("No references found at position"))?;
let frange =
def.rename_range(&sema).ok_or_else(|| format_err!("No references found at position"))?;
Ok(RangeInfo::new(frange.range, ()))
}
@ -98,14 +77,7 @@ pub(crate) fn rename_with_semantics(
}
}
match def {
Definition::ModuleDef(hir::ModuleDef::Module(module)) => rename_mod(sema, module, new_name),
Definition::SelfType(_) => bail!("Cannot rename `Self`"),
Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => {
bail!("Cannot rename builtin type")
}
def => rename_reference(sema, def, new_name),
}
def.rename(sema, new_name)
}
/// Called by the client when it is about to rename a file.
@ -116,38 +88,12 @@ pub(crate) fn will_rename_file(
) -> Option<SourceChange> {
let sema = Semantics::new(db);
let module = sema.to_module_def(file_id)?;
let mut change = rename_mod(&sema, module, new_name_stem).ok()?;
let def = Definition::ModuleDef(module.into());
let mut change = def.rename(&sema, new_name_stem).ok()?;
change.file_system_edits.clear();
Some(change)
}
#[derive(Copy, Clone, Debug, PartialEq)]
enum IdentifierKind {
Ident,
Lifetime,
Underscore,
}
impl IdentifierKind {
fn classify(new_name: &str) -> RenameResult<IdentifierKind> {
match lex_single_syntax_kind(new_name) {
Some(res) => match res {
(SyntaxKind::IDENT, _) => Ok(IdentifierKind::Ident),
(T![_], _) => Ok(IdentifierKind::Underscore),
(SyntaxKind::LIFETIME_IDENT, _) if new_name != "'static" && new_name != "'_" => {
Ok(IdentifierKind::Lifetime)
}
(SyntaxKind::LIFETIME_IDENT, _) => {
bail!("Invalid name `{}`: not a lifetime identifier", new_name)
}
(_, Some(syntax_error)) => bail!("Invalid name `{}`: {}", new_name, syntax_error),
(_, None) => bail!("Invalid name `{}`: not an identifier", new_name),
},
None => bail!("Invalid name `{}`: not an identifier", new_name),
}
}
}
fn find_definition(
sema: &Semantics<RootDatabase>,
syntax: &SyntaxNode,
@ -189,126 +135,6 @@ fn find_definition(
.ok_or_else(|| format_err!("No references found at position"))
}
fn rename_mod(
sema: &Semantics<RootDatabase>,
module: hir::Module,
new_name: &str,
) -> RenameResult<SourceChange> {
if IdentifierKind::classify(new_name)? != IdentifierKind::Ident {
bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
}
let mut source_change = SourceChange::default();
let InFile { file_id, value: def_source } = module.definition_source(sema.db);
let file_id = file_id.original_file(sema.db);
if let ModuleSource::SourceFile(..) = def_source {
// mod is defined in path/to/dir/mod.rs
let path = if module.is_mod_rs(sema.db) {
format!("../{}/mod.rs", new_name)
} else {
format!("{}.rs", new_name)
};
let dst = AnchoredPathBuf { anchor: file_id, path };
let move_file = FileSystemEdit::MoveFile { src: file_id, dst };
source_change.push_file_system_edit(move_file);
}
if let Some(InFile { file_id, value: decl_source }) = module.declaration_source(sema.db) {
let file_id = file_id.original_file(sema.db);
match decl_source.name() {
Some(name) => source_change.insert_source_edit(
file_id,
TextEdit::replace(name.syntax().text_range(), new_name.to_string()),
),
_ => never!("Module source node is missing a name"),
}
}
let def = Definition::ModuleDef(hir::ModuleDef::Module(module));
let usages = def.usages(sema).all();
let ref_edits = usages.iter().map(|(&file_id, references)| {
(file_id, source_edit_from_references(references, def, new_name))
});
source_change.extend(ref_edits);
Ok(source_change)
}
fn rename_reference(
sema: &Semantics<RootDatabase>,
mut def: Definition,
new_name: &str,
) -> RenameResult<SourceChange> {
let ident_kind = IdentifierKind::classify(new_name)?;
if matches!(
def, // is target a lifetime?
Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
) {
match ident_kind {
IdentifierKind::Ident | IdentifierKind::Underscore => {
cov_mark::hit!(rename_not_a_lifetime_ident_ref);
bail!("Invalid name `{}`: not a lifetime identifier", new_name);
}
IdentifierKind::Lifetime => cov_mark::hit!(rename_lifetime),
}
} else {
match (ident_kind, def) {
(IdentifierKind::Lifetime, _) => {
cov_mark::hit!(rename_not_an_ident_ref);
bail!("Invalid name `{}`: not an identifier", new_name);
}
(IdentifierKind::Ident, _) => cov_mark::hit!(rename_non_local),
(IdentifierKind::Underscore, _) => (),
}
}
def = match def {
// HACK: resolve trait impl items to the item def of the trait definition
// so that we properly resolve all trait item references
Definition::ModuleDef(mod_def) => mod_def
.as_assoc_item(sema.db)
.and_then(|it| it.containing_trait_impl(sema.db))
.and_then(|it| {
it.items(sema.db).into_iter().find_map(|it| match (it, mod_def) {
(hir::AssocItem::Function(trait_func), hir::ModuleDef::Function(func))
if trait_func.name(sema.db) == func.name(sema.db) =>
{
Some(Definition::ModuleDef(hir::ModuleDef::Function(trait_func)))
}
(hir::AssocItem::Const(trait_konst), hir::ModuleDef::Const(konst))
if trait_konst.name(sema.db) == konst.name(sema.db) =>
{
Some(Definition::ModuleDef(hir::ModuleDef::Const(trait_konst)))
}
(
hir::AssocItem::TypeAlias(trait_type_alias),
hir::ModuleDef::TypeAlias(type_alias),
) if trait_type_alias.name(sema.db) == type_alias.name(sema.db) => {
Some(Definition::ModuleDef(hir::ModuleDef::TypeAlias(trait_type_alias)))
}
_ => None,
})
})
.unwrap_or(def),
_ => def,
};
let usages = def.usages(sema).all();
if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
cov_mark::hit!(rename_underscore_multiple);
bail!("Cannot rename reference to `_` as it is being referenced multiple times");
}
let mut source_change = SourceChange::default();
source_change.extend(usages.iter().map(|(&file_id, references)| {
(file_id, source_edit_from_references(references, def, new_name))
}));
let (file_id, edit) = source_edit_from_def(sema, def, new_name)?;
source_change.insert_source_edit(file_id, edit);
Ok(source_change)
}
fn rename_to_self(sema: &Semantics<RootDatabase>, local: hir::Local) -> RenameResult<SourceChange> {
if never!(local.is_self(sema.db)) {
bail!("rename_to_self invoked on self");
@ -426,243 +252,6 @@ fn text_edit_from_self_param(self_param: &ast::SelfParam, new_name: &str) -> Opt
Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))
}
fn source_edit_from_references(
references: &[FileReference],
def: Definition,
new_name: &str,
) -> TextEdit {
let mut edit = TextEdit::builder();
for reference in references {
let (range, replacement) = match &reference.name {
// if the ranges differ then the node is inside a macro call, we can't really attempt
// to make special rewrites like shorthand syntax and such, so just rename the node in
// the macro input
ast::NameLike::NameRef(name_ref)
if name_ref.syntax().text_range() == reference.range =>
{
source_edit_from_name_ref(name_ref, new_name, def)
}
ast::NameLike::Name(name) if name.syntax().text_range() == reference.range => {
source_edit_from_name(name, new_name)
}
_ => None,
}
.unwrap_or_else(|| (reference.range, new_name.to_string()));
edit.replace(range, replacement);
}
edit.finish()
}
fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange, String)> {
if let Some(_) = ast::RecordPatField::for_field_name(name) {
if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
return Some((
TextRange::empty(ident_pat.syntax().text_range().start()),
[new_name, ": "].concat(),
));
}
}
None
}
fn source_edit_from_name_ref(
name_ref: &ast::NameRef,
new_name: &str,
def: Definition,
) -> Option<(TextRange, String)> {
if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) {
let rcf_name_ref = record_field.name_ref();
let rcf_expr = record_field.expr();
match (rcf_name_ref, rcf_expr.and_then(|it| it.name_ref())) {
// field: init-expr, check if we can use a field init shorthand
(Some(field_name), Some(init)) => {
if field_name == *name_ref {
if init.text() == new_name {
cov_mark::hit!(test_rename_field_put_init_shorthand);
// same names, we can use a shorthand here instead.
// we do not want to erase attributes hence this range start
let s = field_name.syntax().text_range().start();
let e = record_field.syntax().text_range().end();
return Some((TextRange::new(s, e), new_name.to_owned()));
}
} else if init == *name_ref {
if field_name.text() == new_name {
cov_mark::hit!(test_rename_local_put_init_shorthand);
// same names, we can use a shorthand here instead.
// we do not want to erase attributes hence this range start
let s = field_name.syntax().text_range().start();
let e = record_field.syntax().text_range().end();
return Some((TextRange::new(s, e), new_name.to_owned()));
}
}
None
}
// init shorthand
// FIXME: instead of splitting the shorthand, recursively trigger a rename of the
// other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
(None, Some(_)) if matches!(def, Definition::Field(_)) => {
cov_mark::hit!(test_rename_field_in_field_shorthand);
let s = name_ref.syntax().text_range().start();
Some((TextRange::empty(s), format!("{}: ", new_name)))
}
(None, Some(_)) if matches!(def, Definition::Local(_)) => {
cov_mark::hit!(test_rename_local_in_field_shorthand);
let s = name_ref.syntax().text_range().end();
Some((TextRange::empty(s), format!(": {}", new_name)))
}
_ => None,
}
} else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
let rcf_name_ref = record_field.name_ref();
let rcf_pat = record_field.pat();
match (rcf_name_ref, rcf_pat) {
// field: rename
(Some(field_name), Some(ast::Pat::IdentPat(pat))) if field_name == *name_ref => {
// field name is being renamed
if pat.name().map_or(false, |it| it.text() == new_name) {
cov_mark::hit!(test_rename_field_put_init_shorthand_pat);
// same names, we can use a shorthand here instead/
// we do not want to erase attributes hence this range start
let s = field_name.syntax().text_range().start();
let e = record_field.syntax().text_range().end();
Some((TextRange::new(s, e), pat.to_string()))
} else {
None
}
}
_ => None,
}
} else {
None
}
}
fn source_edit_from_def(
sema: &Semantics<RootDatabase>,
def: Definition,
new_name: &str,
) -> RenameResult<(FileId, TextEdit)> {
let frange: FileRange = def_name_range(sema, def)
.ok_or_else(|| format_err!("No identifier available to rename"))?;
let mut replacement_text = String::new();
let mut repl_range = frange.range;
if let Definition::Local(local) = def {
if let Either::Left(pat) = local.source(sema.db).value {
if matches!(
pat.syntax().parent().and_then(ast::RecordPatField::cast),
Some(pat_field) if pat_field.name_ref().is_none()
) {
replacement_text.push_str(": ");
replacement_text.push_str(new_name);
repl_range = TextRange::new(
pat.syntax().text_range().end(),
pat.syntax().text_range().end(),
);
}
}
}
if replacement_text.is_empty() {
replacement_text.push_str(new_name);
}
let edit = TextEdit::replace(repl_range, replacement_text);
Ok((frange.file_id, edit))
}
fn def_name_range(sema: &Semantics<RootDatabase>, def: Definition) -> Option<FileRange> {
// FIXME: the `original_file_range` calls here are wrong -- they never fail,
// and _fall back_ to the entirety of the macro call. Such fall back is
// incorrect for renames. The safe behavior would be to return an error for
// such cases. The correct behavior would be to return an auxiliary list of
// "can't rename these occurrences in macros" items, and then show some kind
// of a dialog to the user.
let res = match def {
Definition::Macro(mac) => {
let src = mac.source(sema.db)?;
let name = match &src.value {
Either::Left(it) => it.name()?,
Either::Right(it) => it.name()?,
};
src.with_value(name.syntax()).original_file_range(sema.db)
}
Definition::Field(field) => {
let src = field.source(sema.db)?;
match &src.value {
FieldSource::Named(record_field) => {
let name = record_field.name()?;
src.with_value(name.syntax()).original_file_range(sema.db)
}
FieldSource::Pos(_) => {
return None;
}
}
}
Definition::ModuleDef(module_def) => match module_def {
hir::ModuleDef::Module(module) => {
let src = module.declaration_source(sema.db)?;
let name = src.value.name()?;
src.with_value(name.syntax()).original_file_range(sema.db)
}
hir::ModuleDef::Function(it) => name_range(it, sema)?,
hir::ModuleDef::Adt(adt) => match adt {
hir::Adt::Struct(it) => name_range(it, sema)?,
hir::Adt::Union(it) => name_range(it, sema)?,
hir::Adt::Enum(it) => name_range(it, sema)?,
},
hir::ModuleDef::Variant(it) => name_range(it, sema)?,
hir::ModuleDef::Const(it) => name_range(it, sema)?,
hir::ModuleDef::Static(it) => name_range(it, sema)?,
hir::ModuleDef::Trait(it) => name_range(it, sema)?,
hir::ModuleDef::TypeAlias(it) => name_range(it, sema)?,
hir::ModuleDef::BuiltinType(_) => return None,
},
Definition::SelfType(_) => return None,
Definition::Local(local) => {
let src = local.source(sema.db);
let name = match &src.value {
Either::Left(bind_pat) => bind_pat.name()?,
Either::Right(_) => return None,
};
src.with_value(name.syntax()).original_file_range(sema.db)
}
Definition::GenericParam(generic_param) => match generic_param {
hir::GenericParam::TypeParam(type_param) => {
let src = type_param.source(sema.db)?;
let name = match &src.value {
Either::Left(_) => return None,
Either::Right(type_param) => type_param.name()?,
};
src.with_value(name.syntax()).original_file_range(sema.db)
}
hir::GenericParam::LifetimeParam(lifetime_param) => {
let src = lifetime_param.source(sema.db)?;
let lifetime = src.value.lifetime()?;
src.with_value(lifetime.syntax()).original_file_range(sema.db)
}
hir::GenericParam::ConstParam(it) => name_range(it, sema)?,
},
Definition::Label(label) => {
let src = label.source(sema.db);
let lifetime = src.value.lifetime()?;
src.with_value(lifetime.syntax()).original_file_range(sema.db)
}
};
return Some(res);
fn name_range<D>(def: D, sema: &Semantics<RootDatabase>) -> Option<FileRange>
where
D: HasSource,
D::Ast: ast::NameOwner,
{
let src = def.source(sema.db)?;
let name = src.value.name()?;
let res = src.with_value(name.syntax()).original_file_range(sema.db);
Some(res)
}
}
#[cfg(test)]
mod tests {
use expect_test::{expect, Expect};

4
crates/ide_db/src/lib.rs
View File

@ -8,7 +8,6 @@ pub mod label;
pub mod line_index;
pub mod symbol_index;
pub mod defs;
pub mod search;
pub mod items_locator;
pub mod source_change;
pub mod ty_filter;
@ -16,6 +15,9 @@ pub mod traits;
pub mod call_info;
pub mod helpers;
pub mod search;
pub mod rename;
use std::{fmt, sync::Arc};
use base_db::{

444
crates/ide_db/src/rename.rs Normal file
View File

@ -0,0 +1,444 @@
use std::fmt;
use base_db::{AnchoredPathBuf, FileId, FileRange};
use either::Either;
use hir::{AsAssocItem, FieldSource, HasSource, InFile, ModuleSource, Semantics};
use stdx::never;
use syntax::{
ast::{self, NameOwner},
lex_single_syntax_kind, AstNode, SyntaxKind, TextRange, T,
};
use text_edit::TextEdit;
use crate::{
defs::Definition,
search::FileReference,
source_change::{FileSystemEdit, SourceChange},
RootDatabase,
};
pub type Result<T, E = RenameError> = std::result::Result<T, E>;
#[derive(Debug)]
pub struct RenameError(pub String);
impl fmt::Display for RenameError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.0, f)
}
}
#[macro_export]
macro_rules! _format_err {
($fmt:expr) => { RenameError(format!($fmt)) };
($fmt:expr, $($arg:tt)+) => { RenameError(format!($fmt, $($arg)+)) }
}
pub use _format_err as format_err;
#[macro_export]
macro_rules! _bail {
($($tokens:tt)*) => { return Err(format_err!($($tokens)*)) }
}
pub use _bail as bail;
impl Definition {
pub fn rename(&self, sema: &Semantics<RootDatabase>, new_name: &str) -> Result<SourceChange> {
match *self {
Definition::ModuleDef(hir::ModuleDef::Module(module)) => {
rename_mod(sema, module, new_name)
}
Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => {
bail!("Cannot rename builtin type")
}
Definition::SelfType(_) => bail!("Cannot rename `Self`"),
def => rename_reference(sema, def, new_name),
}
}
/// Textual range of the identifier which will change when renaming this
/// `Definition`. Note that some definitions, like buitin types, can't be
/// renamed.
pub fn rename_range(self, sema: &Semantics<RootDatabase>) -> Option<FileRange> {
// FIXME: the `original_file_range` calls here are wrong -- they never fail,
// and _fall back_ to the entirety of the macro call. Such fall back is
// incorrect for renames. The safe behavior would be to return an error for
// such cases. The correct behavior would be to return an auxiliary list of
// "can't rename these occurrences in macros" items, and then show some kind
// of a dialog to the user.
let res = match self {
Definition::Macro(mac) => {
let src = mac.source(sema.db)?;
let name = match &src.value {
Either::Left(it) => it.name()?,
Either::Right(it) => it.name()?,
};
src.with_value(name.syntax()).original_file_range(sema.db)
}
Definition::Field(field) => {
let src = field.source(sema.db)?;
match &src.value {
FieldSource::Named(record_field) => {
let name = record_field.name()?;
src.with_value(name.syntax()).original_file_range(sema.db)
}
FieldSource::Pos(_) => {
return None;
}
}
}
Definition::ModuleDef(module_def) => match module_def {
hir::ModuleDef::Module(module) => {
let src = module.declaration_source(sema.db)?;
let name = src.value.name()?;
src.with_value(name.syntax()).original_file_range(sema.db)
}
hir::ModuleDef::Function(it) => name_range(it, sema)?,
hir::ModuleDef::Adt(adt) => match adt {
hir::Adt::Struct(it) => name_range(it, sema)?,
hir::Adt::Union(it) => name_range(it, sema)?,
hir::Adt::Enum(it) => name_range(it, sema)?,
},
hir::ModuleDef::Variant(it) => name_range(it, sema)?,
hir::ModuleDef::Const(it) => name_range(it, sema)?,
hir::ModuleDef::Static(it) => name_range(it, sema)?,
hir::ModuleDef::Trait(it) => name_range(it, sema)?,
hir::ModuleDef::TypeAlias(it) => name_range(it, sema)?,
hir::ModuleDef::BuiltinType(_) => return None,
},
Definition::SelfType(_) => return None,
Definition::Local(local) => {
let src = local.source(sema.db);
let name = match &src.value {
Either::Left(bind_pat) => bind_pat.name()?,
Either::Right(_) => return None,
};
src.with_value(name.syntax()).original_file_range(sema.db)
}
Definition::GenericParam(generic_param) => match generic_param {
hir::GenericParam::TypeParam(type_param) => {
let src = type_param.source(sema.db)?;
let name = match &src.value {
Either::Left(_) => return None,
Either::Right(type_param) => type_param.name()?,
};
src.with_value(name.syntax()).original_file_range(sema.db)
}
hir::GenericParam::LifetimeParam(lifetime_param) => {
let src = lifetime_param.source(sema.db)?;
let lifetime = src.value.lifetime()?;
src.with_value(lifetime.syntax()).original_file_range(sema.db)
}
hir::GenericParam::ConstParam(it) => name_range(it, sema)?,
},
Definition::Label(label) => {
let src = label.source(sema.db);
let lifetime = src.value.lifetime()?;
src.with_value(lifetime.syntax()).original_file_range(sema.db)
}
};
return Some(res);
fn name_range<D>(def: D, sema: &Semantics<RootDatabase>) -> Option<FileRange>
where
D: HasSource,
D::Ast: ast::NameOwner,
{
let src = def.source(sema.db)?;
let name = src.value.name()?;
let res = src.with_value(name.syntax()).original_file_range(sema.db);
Some(res)
}
}
}
fn rename_mod(
sema: &Semantics<RootDatabase>,
module: hir::Module,
new_name: &str,
) -> Result<SourceChange> {
if IdentifierKind::classify(new_name)? != IdentifierKind::Ident {
bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
}
let mut source_change = SourceChange::default();
let InFile { file_id, value: def_source } = module.definition_source(sema.db);
let file_id = file_id.original_file(sema.db);
if let ModuleSource::SourceFile(..) = def_source {
// mod is defined in path/to/dir/mod.rs
let path = if module.is_mod_rs(sema.db) {
format!("../{}/mod.rs", new_name)
} else {
format!("{}.rs", new_name)
};
let dst = AnchoredPathBuf { anchor: file_id, path };
let move_file = FileSystemEdit::MoveFile { src: file_id, dst };
source_change.push_file_system_edit(move_file);
}
if let Some(InFile { file_id, value: decl_source }) = module.declaration_source(sema.db) {
let file_id = file_id.original_file(sema.db);
match decl_source.name() {
Some(name) => source_change.insert_source_edit(
file_id,
TextEdit::replace(name.syntax().text_range(), new_name.to_string()),
),
_ => never!("Module source node is missing a name"),
}
}
let def = Definition::ModuleDef(hir::ModuleDef::Module(module));
let usages = def.usages(sema).all();
let ref_edits = usages.iter().map(|(&file_id, references)| {
(file_id, source_edit_from_references(references, def, new_name))
});
source_change.extend(ref_edits);
Ok(source_change)
}
fn rename_reference(
sema: &Semantics<RootDatabase>,
mut def: Definition,
new_name: &str,
) -> Result<SourceChange> {
let ident_kind = IdentifierKind::classify(new_name)?;
if matches!(
def, // is target a lifetime?
Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
) {
match ident_kind {
IdentifierKind::Ident | IdentifierKind::Underscore => {
cov_mark::hit!(rename_not_a_lifetime_ident_ref);
bail!("Invalid name `{}`: not a lifetime identifier", new_name);
}
IdentifierKind::Lifetime => cov_mark::hit!(rename_lifetime),
}
} else {
match (ident_kind, def) {
(IdentifierKind::Lifetime, _) => {
cov_mark::hit!(rename_not_an_ident_ref);
bail!("Invalid name `{}`: not an identifier", new_name);
}
(IdentifierKind::Ident, _) => cov_mark::hit!(rename_non_local),
(IdentifierKind::Underscore, _) => (),
}
}
def = match def {
// HACK: resolve trait impl items to the item def of the trait definition
// so that we properly resolve all trait item references
Definition::ModuleDef(mod_def) => mod_def
.as_assoc_item(sema.db)
.and_then(|it| it.containing_trait_impl(sema.db))
.and_then(|it| {
it.items(sema.db).into_iter().find_map(|it| match (it, mod_def) {
(hir::AssocItem::Function(trait_func), hir::ModuleDef::Function(func))
if trait_func.name(sema.db) == func.name(sema.db) =>
{
Some(Definition::ModuleDef(hir::ModuleDef::Function(trait_func)))
}
(hir::AssocItem::Const(trait_konst), hir::ModuleDef::Const(konst))
if trait_konst.name(sema.db) == konst.name(sema.db) =>
{
Some(Definition::ModuleDef(hir::ModuleDef::Const(trait_konst)))
}
(
hir::AssocItem::TypeAlias(trait_type_alias),
hir::ModuleDef::TypeAlias(type_alias),
) if trait_type_alias.name(sema.db) == type_alias.name(sema.db) => {
Some(Definition::ModuleDef(hir::ModuleDef::TypeAlias(trait_type_alias)))
}
_ => None,
})
})
.unwrap_or(def),
_ => def,
};
let usages = def.usages(sema).all();
if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
cov_mark::hit!(rename_underscore_multiple);
bail!("Cannot rename reference to `_` as it is being referenced multiple times");
}
let mut source_change = SourceChange::default();
source_change.extend(usages.iter().map(|(&file_id, references)| {
(file_id, source_edit_from_references(references, def, new_name))
}));
let (file_id, edit) = source_edit_from_def(sema, def, new_name)?;
source_change.insert_source_edit(file_id, edit);
Ok(source_change)
}
pub fn source_edit_from_references(
references: &[FileReference],
def: Definition,
new_name: &str,
) -> TextEdit {
let mut edit = TextEdit::builder();
for reference in references {
let (range, replacement) = match &reference.name {
// if the ranges differ then the node is inside a macro call, we can't really attempt
// to make special rewrites like shorthand syntax and such, so just rename the node in
// the macro input
ast::NameLike::NameRef(name_ref)
if name_ref.syntax().text_range() == reference.range =>
{
source_edit_from_name_ref(name_ref, new_name, def)
}
ast::NameLike::Name(name) if name.syntax().text_range() == reference.range => {
source_edit_from_name(name, new_name)
}
_ => None,
}
.unwrap_or_else(|| (reference.range, new_name.to_string()));
edit.replace(range, replacement);
}
edit.finish()
}
fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange, String)> {
if let Some(_) = ast::RecordPatField::for_field_name(name) {
if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
return Some((
TextRange::empty(ident_pat.syntax().text_range().start()),
[new_name, ": "].concat(),
));
}
}
None
}
fn source_edit_from_name_ref(
name_ref: &ast::NameRef,
new_name: &str,
def: Definition,
) -> Option<(TextRange, String)> {
if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) {
let rcf_name_ref = record_field.name_ref();
let rcf_expr = record_field.expr();
match (rcf_name_ref, rcf_expr.and_then(|it| it.name_ref())) {
// field: init-expr, check if we can use a field init shorthand
(Some(field_name), Some(init)) => {
if field_name == *name_ref {
if init.text() == new_name {
cov_mark::hit!(test_rename_field_put_init_shorthand);
// same names, we can use a shorthand here instead.
// we do not want to erase attributes hence this range start
let s = field_name.syntax().text_range().start();
let e = record_field.syntax().text_range().end();
return Some((TextRange::new(s, e), new_name.to_owned()));
}
} else if init == *name_ref {
if field_name.text() == new_name {
cov_mark::hit!(test_rename_local_put_init_shorthand);
// same names, we can use a shorthand here instead.
// we do not want to erase attributes hence this range start
let s = field_name.syntax().text_range().start();
let e = record_field.syntax().text_range().end();
return Some((TextRange::new(s, e), new_name.to_owned()));
}
}
None
}
// init shorthand
// FIXME: instead of splitting the shorthand, recursively trigger a rename of the
// other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
(None, Some(_)) if matches!(def, Definition::Field(_)) => {
cov_mark::hit!(test_rename_field_in_field_shorthand);
let s = name_ref.syntax().text_range().start();
Some((TextRange::empty(s), format!("{}: ", new_name)))
}
(None, Some(_)) if matches!(def, Definition::Local(_)) => {
cov_mark::hit!(test_rename_local_in_field_shorthand);
let s = name_ref.syntax().text_range().end();
Some((TextRange::empty(s), format!(": {}", new_name)))
}
_ => None,
}
} else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
let rcf_name_ref = record_field.name_ref();
let rcf_pat = record_field.pat();
match (rcf_name_ref, rcf_pat) {
// field: rename
(Some(field_name), Some(ast::Pat::IdentPat(pat))) if field_name == *name_ref => {
// field name is being renamed
if pat.name().map_or(false, |it| it.text() == new_name) {
cov_mark::hit!(test_rename_field_put_init_shorthand_pat);
// same names, we can use a shorthand here instead/
// we do not want to erase attributes hence this range start
let s = field_name.syntax().text_range().start();
let e = record_field.syntax().text_range().end();
Some((TextRange::new(s, e), pat.to_string()))
} else {
None
}
}
_ => None,
}
} else {
None
}
}
fn source_edit_from_def(
sema: &Semantics<RootDatabase>,
def: Definition,
new_name: &str,
) -> Result<(FileId, TextEdit)> {
let frange =
def.rename_range(sema).ok_or_else(|| format_err!("No identifier available to rename"))?;
let mut replacement_text = String::new();
let mut repl_range = frange.range;
if let Definition::Local(local) = def {
if let Either::Left(pat) = local.source(sema.db).value {
if matches!(
pat.syntax().parent().and_then(ast::RecordPatField::cast),
Some(pat_field) if pat_field.name_ref().is_none()
) {
replacement_text.push_str(": ");
replacement_text.push_str(new_name);
repl_range = TextRange::new(
pat.syntax().text_range().end(),
pat.syntax().text_range().end(),
);
}
}
}
if replacement_text.is_empty() {
replacement_text.push_str(new_name);
}
let edit = TextEdit::replace(repl_range, replacement_text);
Ok((frange.file_id, edit))
}
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum IdentifierKind {
Ident,
Lifetime,
Underscore,
}
impl IdentifierKind {
pub fn classify(new_name: &str) -> Result<IdentifierKind> {
match lex_single_syntax_kind(new_name) {
Some(res) => match res {
(SyntaxKind::IDENT, _) => Ok(IdentifierKind::Ident),
(T![_], _) => Ok(IdentifierKind::Underscore),
(SyntaxKind::LIFETIME_IDENT, _) if new_name != "'static" && new_name != "'_" => {
Ok(IdentifierKind::Lifetime)
}
(SyntaxKind::LIFETIME_IDENT, _) => {
bail!("Invalid name `{}`: not a lifetime identifier", new_name)
}
(_, Some(syntax_error)) => bail!("Invalid name `{}`: {}", new_name, syntax_error),
(_, None) => bail!("Invalid name `{}`: not an identifier", new_name),
},
None => bail!("Invalid name `{}`: not an identifier", new_name),
}
}
}

46
crates/ide_diagnostics/src/incorrect_case.rs
View File

@ -1,5 +1,5 @@
use hir::{db::AstDatabase, InFile};
use ide_db::{assists::Assist, base_db::FilePosition};
use ide_db::{assists::Assist, defs::NameClass};
use syntax::AstNode;
use crate::{
@ -27,35 +27,26 @@ pub(super) fn incorrect_case(ctx: &DiagnosticsContext<'_>, d: &hir::IncorrectCas
}
fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::IncorrectCase) -> Option<Vec<Assist>> {
if true {
return None;
}
let root = ctx.sema.db.parse_or_expand(d.file)?;
let name_node = d.ident.to_node(&root);
let def = NameClass::classify(&ctx.sema, &name_node)?.defined(ctx.sema.db)?;
let name_node = InFile::new(d.file, name_node.syntax());
let frange = name_node.original_file_range(ctx.sema.db);
let _file_position = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
let label = format!("Rename to {}", d.suggested_text);
let res = unresolved_fix("change_case", &label, frange.range);
let mut res = unresolved_fix("change_case", &label, frange.range);
if ctx.resolve.should_resolve(&res.id) {
//let source_change = rename_with_semantics(&ctx.sema, file_position, &d.suggested_text);
//res.source_change = Some(source_change.ok().unwrap_or_default());
todo!()
let source_change = def.rename(&ctx.sema, &d.suggested_text);
res.source_change = Some(source_change.ok().unwrap_or_default());
}
Some(vec![res])
}
#[cfg(TODO)]
#[cfg(test)]
mod change_case {
use crate::{
fixture,
tests::{check_diagnostics, check_fix},
AssistResolveStrategy, DiagnosticsConfig,
};
use crate::tests::{check_diagnostics, check_fix};
#[test]
fn test_rename_incorrect_case() {
@ -123,7 +114,7 @@ fn some_fn() {
check_diagnostics(
r#"
fn foo() {
const ANOTHER_ITEM$0: &str = "some_item";
const ANOTHER_ITEM: &str = "some_item";
}
"#,
);
@ -155,20 +146,13 @@ impl TestStruct {
#[test]
fn test_single_incorrect_case_diagnostic_in_function_name_issue_6970() {
let input = r#"fn FOO$0() {}"#;
let expected = r#"fn foo() {}"#;
let (analysis, file_position) = fixture::position(input);
let diagnostics = analysis
.diagnostics(
&DiagnosticsConfig::default(),
AssistResolveStrategy::All,
file_position.file_id,
)
.unwrap();
assert_eq!(diagnostics.len(), 1);
check_fix(input, expected);
check_diagnostics(
r#"
fn FOO() {}
// ^^^ Function `FOO` should have snake_case name, e.g. `foo`
"#,
);
check_fix(r#"fn FOO$0() {}"#, r#"fn foo() {}"#);
}
#[test]