mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-26 08:44:35 +00:00
restructure a bit
This commit is contained in:
Ekaterina Babshukova
parent
0dd08b8023
commit
d26d0ada50
@ -10,7 +10,7 @@ use ra_syntax::{
|
||||
use crate::{
|
||||
db::RootDatabase,
|
||||
display::ShortLabel,
|
||||
name_kind::{classify_name_ref, NameKind::*},
|
||||
references::{classify_name_ref, NameKind::*},
|
||||
FilePosition, NavigationTarget, RangeInfo,
|
||||
};
|
||||
|
||||
@ -54,8 +54,7 @@ pub(crate) fn reference_definition(
|
||||
) -> ReferenceResult {
|
||||
use self::ReferenceResult::*;
|
||||
|
||||
let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
|
||||
let name_kind = classify_name_ref(db, file_id, &analyzer, &name_ref).and_then(|d| Some(d.item));
|
||||
let name_kind = classify_name_ref(db, file_id, &name_ref).and_then(|d| Some(d.item));
|
||||
match name_kind {
|
||||
Some(Macro(mac)) => return Exact(NavigationTarget::from_macro_def(db, mac)),
|
||||
Some(FieldAccess(field)) => return Exact(NavigationTarget::from_field(db, field)),
|
||||
|
||||
@ -14,7 +14,7 @@ use crate::{
|
||||
description_from_symbol, docs_from_symbol, macro_label, rust_code_markup,
|
||||
rust_code_markup_with_doc, ShortLabel,
|
||||
},
|
||||
name_kind::{classify_name_ref, NameKind::*},
|
||||
references::{classify_name_ref, NameKind::*},
|
||||
FilePosition, FileRange, RangeInfo,
|
||||
};
|
||||
|
||||
@ -99,11 +99,9 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
|
||||
|
||||
let mut range = None;
|
||||
if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
|
||||
let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
|
||||
|
||||
let mut no_fallback = false;
|
||||
let name_kind = classify_name_ref(db, position.file_id, &analyzer, &name_ref)
|
||||
.and_then(|d| Some(d.item));
|
||||
let name_kind =
|
||||
classify_name_ref(db, position.file_id, &name_ref).and_then(|d| Some(d.item));
|
||||
match name_kind {
|
||||
Some(Macro(it)) => {
|
||||
let src = it.source(db);
|
||||
|
||||
@ -19,7 +19,6 @@ mod feature_flags;
|
||||
mod status;
|
||||
mod completion;
|
||||
mod runnables;
|
||||
mod name_kind;
|
||||
mod goto_definition;
|
||||
mod goto_type_definition;
|
||||
mod extend_selection;
|
||||
@ -41,7 +40,6 @@ mod matching_brace;
|
||||
mod display;
|
||||
mod inlay_hints;
|
||||
mod wasm_shims;
|
||||
mod search_scope;
|
||||
|
||||
#[cfg(test)]
|
||||
mod marks;
|
||||
|
||||
@ -1,287 +0,0 @@
|
||||
//! FIXME: write short doc here
|
||||
|
||||
use hir::{
|
||||
db::AstDatabase, Adt, AssocItem, DefWithBody, Either, EnumVariant, FromSource, HasSource,
|
||||
HirFileId, MacroDef, Module, ModuleDef, ModuleSource, Path, PathResolution, Source,
|
||||
SourceAnalyzer, StructField, Ty, VariantDef,
|
||||
};
|
||||
use ra_db::FileId;
|
||||
use ra_syntax::{ast, ast::VisibilityOwner, match_ast, AstNode, AstPtr};
|
||||
|
||||
use crate::db::RootDatabase;
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub enum NameKind {
|
||||
Macro(MacroDef),
|
||||
FieldAccess(StructField),
|
||||
AssocItem(AssocItem),
|
||||
Def(ModuleDef),
|
||||
SelfType(Ty),
|
||||
Pat((DefWithBody, AstPtr<ast::BindPat>)),
|
||||
SelfParam(AstPtr<ast::SelfParam>),
|
||||
GenericParam(u32),
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Eq)]
|
||||
pub(crate) struct Definition {
|
||||
pub visibility: Option<ast::Visibility>,
|
||||
pub container: Module,
|
||||
pub item: NameKind,
|
||||
}
|
||||
|
||||
trait HasDefinition {
|
||||
type Def;
|
||||
type Ref;
|
||||
|
||||
fn definition(self, db: &RootDatabase) -> Definition;
|
||||
fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Definition>;
|
||||
fn from_ref(
|
||||
db: &RootDatabase,
|
||||
analyzer: &SourceAnalyzer,
|
||||
refer: Self::Ref,
|
||||
) -> Option<Definition>;
|
||||
}
|
||||
|
||||
pub(crate) fn classify_name_ref(
|
||||
db: &RootDatabase,
|
||||
file_id: FileId,
|
||||
analyzer: &SourceAnalyzer,
|
||||
name_ref: &ast::NameRef,
|
||||
) -> Option<Definition> {
|
||||
let parent = name_ref.syntax().parent()?;
|
||||
match_ast! {
|
||||
match parent {
|
||||
ast::MethodCallExpr(it) => {
|
||||
return AssocItem::from_ref(db, analyzer, it);
|
||||
},
|
||||
ast::FieldExpr(it) => {
|
||||
if let Some(field) = analyzer.resolve_field(&it) {
|
||||
return Some(field.definition(db));
|
||||
}
|
||||
},
|
||||
ast::RecordField(it) => {
|
||||
if let Some(record_lit) = it.syntax().ancestors().find_map(ast::RecordLit::cast) {
|
||||
let variant_def = analyzer.resolve_record_literal(&record_lit)?;
|
||||
let hir_path = Path::from_name_ref(name_ref);
|
||||
let hir_name = hir_path.as_ident()?;
|
||||
let field = variant_def.field(db, hir_name)?;
|
||||
return Some(field.definition(db));
|
||||
}
|
||||
},
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
|
||||
let ast = ModuleSource::from_child_node(db, file_id, &parent);
|
||||
let file_id = file_id.into();
|
||||
let container = Module::from_definition(db, Source { file_id, ast })?;
|
||||
let visibility = None;
|
||||
|
||||
if let Some(macro_call) =
|
||||
parent.parent().and_then(|node| node.parent()).and_then(ast::MacroCall::cast)
|
||||
{
|
||||
if let Some(mac) = analyzer.resolve_macro_call(db, ¯o_call) {
|
||||
return Some(Definition { item: NameKind::Macro(mac), container, visibility });
|
||||
}
|
||||
}
|
||||
|
||||
// General case, a path or a local:
|
||||
let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
|
||||
let resolved = analyzer.resolve_path(db, &path)?;
|
||||
match resolved {
|
||||
PathResolution::Def(def) => Some(def.definition(db)),
|
||||
PathResolution::LocalBinding(Either::A(pat)) => decl_from_pat(db, file_id, pat),
|
||||
PathResolution::LocalBinding(Either::B(par)) => {
|
||||
Some(Definition { item: NameKind::SelfParam(par), container, visibility })
|
||||
}
|
||||
PathResolution::GenericParam(par) => {
|
||||
// FIXME: get generic param def
|
||||
Some(Definition { item: NameKind::GenericParam(par), container, visibility })
|
||||
}
|
||||
PathResolution::Macro(def) => {
|
||||
Some(Definition { item: NameKind::Macro(def), container, visibility })
|
||||
}
|
||||
PathResolution::SelfType(impl_block) => {
|
||||
let ty = impl_block.target_ty(db);
|
||||
let container = impl_block.module();
|
||||
Some(Definition { item: NameKind::SelfType(ty), container, visibility })
|
||||
}
|
||||
PathResolution::AssocItem(assoc) => Some(assoc.definition(db)),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn classify_name(
|
||||
db: &RootDatabase,
|
||||
file_id: FileId,
|
||||
name: &ast::Name,
|
||||
) -> Option<Definition> {
|
||||
let parent = name.syntax().parent()?;
|
||||
let file_id = file_id.into();
|
||||
|
||||
match_ast! {
|
||||
match parent {
|
||||
ast::BindPat(it) => {
|
||||
decl_from_pat(db, file_id, AstPtr::new(&it))
|
||||
},
|
||||
ast::RecordFieldDef(it) => {
|
||||
StructField::from_def(db, file_id, it)
|
||||
},
|
||||
ast::ImplItem(it) => {
|
||||
AssocItem::from_def(db, file_id, it.clone()).or_else(|| {
|
||||
match it {
|
||||
ast::ImplItem::FnDef(f) => ModuleDef::from_def(db, file_id, f.into()),
|
||||
ast::ImplItem::ConstDef(c) => ModuleDef::from_def(db, file_id, c.into()),
|
||||
ast::ImplItem::TypeAliasDef(a) => ModuleDef::from_def(db, file_id, a.into()),
|
||||
}
|
||||
})
|
||||
},
|
||||
ast::EnumVariant(it) => {
|
||||
let src = hir::Source { file_id, ast: it.clone() };
|
||||
let def: ModuleDef = EnumVariant::from_source(db, src)?.into();
|
||||
Some(def.definition(db))
|
||||
},
|
||||
ast::ModuleItem(it) => {
|
||||
ModuleDef::from_def(db, file_id, it)
|
||||
},
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn decl_from_pat(
|
||||
db: &RootDatabase,
|
||||
file_id: HirFileId,
|
||||
pat: AstPtr<ast::BindPat>,
|
||||
) -> Option<Definition> {
|
||||
let root = db.parse_or_expand(file_id)?;
|
||||
// FIXME: use match_ast!
|
||||
let def = pat.to_node(&root).syntax().ancestors().find_map(|node| {
|
||||
if let Some(it) = ast::FnDef::cast(node.clone()) {
|
||||
let src = hir::Source { file_id, ast: it };
|
||||
Some(hir::Function::from_source(db, src)?.into())
|
||||
} else if let Some(it) = ast::ConstDef::cast(node.clone()) {
|
||||
let src = hir::Source { file_id, ast: it };
|
||||
Some(hir::Const::from_source(db, src)?.into())
|
||||
} else if let Some(it) = ast::StaticDef::cast(node.clone()) {
|
||||
let src = hir::Source { file_id, ast: it };
|
||||
Some(hir::Static::from_source(db, src)?.into())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})?;
|
||||
let item = NameKind::Pat((def, pat));
|
||||
let container = def.module(db);
|
||||
Some(Definition { item, container, visibility: None })
|
||||
}
|
||||
|
||||
impl HasDefinition for StructField {
|
||||
type Def = ast::RecordFieldDef;
|
||||
type Ref = ast::FieldExpr;
|
||||
|
||||
fn definition(self, db: &RootDatabase) -> Definition {
|
||||
let item = NameKind::FieldAccess(self);
|
||||
let parent = self.parent_def(db);
|
||||
let container = parent.module(db);
|
||||
let visibility = match parent {
|
||||
VariantDef::Struct(s) => s.source(db).ast.visibility(),
|
||||
VariantDef::EnumVariant(e) => e.source(db).ast.parent_enum().visibility(),
|
||||
};
|
||||
Definition { item, container, visibility }
|
||||
}
|
||||
|
||||
fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Definition> {
|
||||
let src = hir::Source { file_id, ast: hir::FieldSource::Named(def) };
|
||||
let field = StructField::from_source(db, src)?;
|
||||
Some(field.definition(db))
|
||||
}
|
||||
|
||||
fn from_ref(
|
||||
db: &RootDatabase,
|
||||
analyzer: &SourceAnalyzer,
|
||||
refer: Self::Ref,
|
||||
) -> Option<Definition> {
|
||||
let field = analyzer.resolve_field(&refer)?;
|
||||
Some(field.definition(db))
|
||||
}
|
||||
}
|
||||
|
||||
impl HasDefinition for AssocItem {
|
||||
type Def = ast::ImplItem;
|
||||
type Ref = ast::MethodCallExpr;
|
||||
|
||||
fn definition(self, db: &RootDatabase) -> Definition {
|
||||
let item = NameKind::AssocItem(self);
|
||||
let container = self.module(db);
|
||||
let visibility = match self {
|
||||
AssocItem::Function(f) => f.source(db).ast.visibility(),
|
||||
AssocItem::Const(c) => c.source(db).ast.visibility(),
|
||||
AssocItem::TypeAlias(a) => a.source(db).ast.visibility(),
|
||||
};
|
||||
Definition { item, container, visibility }
|
||||
}
|
||||
|
||||
fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Definition> {
|
||||
if def.syntax().parent().and_then(ast::ItemList::cast).is_none() {
|
||||
return None;
|
||||
}
|
||||
let src = hir::Source { file_id, ast: def };
|
||||
let item = AssocItem::from_source(db, src)?;
|
||||
Some(item.definition(db))
|
||||
}
|
||||
|
||||
fn from_ref(
|
||||
db: &RootDatabase,
|
||||
analyzer: &SourceAnalyzer,
|
||||
refer: Self::Ref,
|
||||
) -> Option<Definition> {
|
||||
let func: AssocItem = analyzer.resolve_method_call(&refer)?.into();
|
||||
Some(func.definition(db))
|
||||
}
|
||||
}
|
||||
|
||||
impl HasDefinition for ModuleDef {
|
||||
type Def = ast::ModuleItem;
|
||||
type Ref = ast::Path;
|
||||
|
||||
fn definition(self, db: &RootDatabase) -> Definition {
|
||||
let (container, visibility) = match self {
|
||||
ModuleDef::Module(it) => {
|
||||
let container = it.parent(db).or_else(|| Some(it)).unwrap();
|
||||
let visibility = it.declaration_source(db).and_then(|s| s.ast.visibility());
|
||||
(container, visibility)
|
||||
}
|
||||
ModuleDef::EnumVariant(it) => {
|
||||
let container = it.module(db);
|
||||
let visibility = it.source(db).ast.parent_enum().visibility();
|
||||
(container, visibility)
|
||||
}
|
||||
ModuleDef::Function(it) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Const(it) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Static(it) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Trait(it) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::TypeAlias(it) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Adt(Adt::Struct(it)) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Adt(Adt::Union(it)) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Adt(Adt::Enum(it)) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::BuiltinType(..) => unreachable!(),
|
||||
};
|
||||
let item = NameKind::Def(self);
|
||||
Definition { item, container, visibility }
|
||||
}
|
||||
|
||||
fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Definition> {
|
||||
let src = hir::Source { file_id, ast: def };
|
||||
let def = ModuleDef::from_source(db, src)?;
|
||||
Some(def.definition(db))
|
||||
}
|
||||
|
||||
fn from_ref(
|
||||
db: &RootDatabase,
|
||||
analyzer: &SourceAnalyzer,
|
||||
refer: Self::Ref,
|
||||
) -> Option<Definition> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: impl HasDefinition for hir::MacroDef
|
||||
@ -1,16 +1,19 @@
|
||||
//! FIXME: write short doc here
|
||||
|
||||
use hir::ModuleSource;
|
||||
use ra_db::{SourceDatabase, SourceDatabaseExt};
|
||||
use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SyntaxNode};
|
||||
use relative_path::{RelativePath, RelativePathBuf};
|
||||
mod classify;
|
||||
mod definition;
|
||||
mod rename;
|
||||
mod search_scope;
|
||||
|
||||
use crate::{
|
||||
db::RootDatabase,
|
||||
name_kind::{classify_name, classify_name_ref, Definition, NameKind::*},
|
||||
search_scope::find_refs,
|
||||
FileId, FilePosition, FileRange, FileSystemEdit, NavigationTarget, RangeInfo, SourceChange,
|
||||
SourceFileEdit, TextRange,
|
||||
use ra_db::{SourceDatabase, SourceDatabaseExt};
|
||||
use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxNode, TextUnit};
|
||||
|
||||
use crate::{db::RootDatabase, FileId, FilePosition, FileRange, NavigationTarget, RangeInfo};
|
||||
|
||||
pub(crate) use self::{
|
||||
classify::{classify_name, classify_name_ref},
|
||||
definition::{Definition, NameKind},
|
||||
rename::rename,
|
||||
};
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
@ -59,169 +62,84 @@ pub(crate) fn find_all_refs(
|
||||
let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position)?;
|
||||
|
||||
let declaration = match def.item {
|
||||
Macro(mac) => NavigationTarget::from_macro_def(db, mac),
|
||||
FieldAccess(field) => NavigationTarget::from_field(db, field),
|
||||
AssocItem(assoc) => NavigationTarget::from_assoc_item(db, assoc),
|
||||
Def(def) => NavigationTarget::from_def(db, def)?,
|
||||
SelfType(ref ty) => match ty.as_adt() {
|
||||
NameKind::Macro(mac) => NavigationTarget::from_macro_def(db, mac),
|
||||
NameKind::FieldAccess(field) => NavigationTarget::from_field(db, field),
|
||||
NameKind::AssocItem(assoc) => NavigationTarget::from_assoc_item(db, assoc),
|
||||
NameKind::Def(def) => NavigationTarget::from_def(db, def)?,
|
||||
NameKind::SelfType(ref ty) => match ty.as_adt() {
|
||||
Some((def_id, _)) => NavigationTarget::from_adt_def(db, def_id),
|
||||
None => return None,
|
||||
},
|
||||
Pat((_, pat)) => NavigationTarget::from_pat(db, position.file_id, pat),
|
||||
SelfParam(par) => NavigationTarget::from_self_param(position.file_id, par),
|
||||
GenericParam(_) => return None,
|
||||
NameKind::Pat((_, pat)) => NavigationTarget::from_pat(db, position.file_id, pat),
|
||||
NameKind::SelfParam(par) => NavigationTarget::from_self_param(position.file_id, par),
|
||||
NameKind::GenericParam(_) => return None,
|
||||
};
|
||||
|
||||
// let references = match name_kind {
|
||||
// Pat((_, pat)) => analyzer
|
||||
// .find_all_refs(&pat.to_node(&syntax))
|
||||
// .into_iter()
|
||||
// .map(move |ref_desc| FileRange { file_id: position.file_id, range: ref_desc.range })
|
||||
// .collect::<Vec<_>>(),
|
||||
// _ => vec![],
|
||||
// };
|
||||
let references = find_refs(db, def, name);
|
||||
let references = process_definition(db, def, name);
|
||||
|
||||
return Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references }));
|
||||
|
||||
fn find_name<'a>(
|
||||
db: &RootDatabase,
|
||||
syntax: &SyntaxNode,
|
||||
position: FilePosition,
|
||||
) -> Option<RangeInfo<(String, Definition)>> {
|
||||
if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, position.offset) {
|
||||
let def = classify_name(db, position.file_id, &name)?;
|
||||
let range = name.syntax().text_range();
|
||||
return Some(RangeInfo::new(range, (name.text().to_string(), def)));
|
||||
}
|
||||
let name_ref = find_node_at_offset::<ast::NameRef>(&syntax, position.offset)?;
|
||||
let range = name_ref.syntax().text_range();
|
||||
let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
|
||||
let def = classify_name_ref(db, position.file_id, &analyzer, &name_ref)?;
|
||||
Some(RangeInfo::new(range, (name_ref.text().to_string(), def)))
|
||||
}
|
||||
Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references }))
|
||||
}
|
||||
|
||||
pub(crate) fn rename(
|
||||
fn find_name<'a>(
|
||||
db: &RootDatabase,
|
||||
position: FilePosition,
|
||||
new_name: &str,
|
||||
) -> Option<RangeInfo<SourceChange>> {
|
||||
let parse = db.parse(position.file_id);
|
||||
if let Some((ast_name, ast_module)) =
|
||||
find_name_and_module_at_offset(parse.tree().syntax(), position)
|
||||
{
|
||||
let range = ast_name.syntax().text_range();
|
||||
rename_mod(db, &ast_name, &ast_module, position, new_name)
|
||||
.map(|info| RangeInfo::new(range, info))
|
||||
} else {
|
||||
rename_reference(db, position, new_name)
|
||||
}
|
||||
}
|
||||
|
||||
fn find_name_and_module_at_offset(
|
||||
syntax: &SyntaxNode,
|
||||
position: FilePosition,
|
||||
) -> Option<(ast::Name, ast::Module)> {
|
||||
let ast_name = find_node_at_offset::<ast::Name>(syntax, position.offset)?;
|
||||
let ast_module = ast::Module::cast(ast_name.syntax().parent()?)?;
|
||||
Some((ast_name, ast_module))
|
||||
}
|
||||
|
||||
fn source_edit_from_file_id_range(
|
||||
file_id: FileId,
|
||||
range: TextRange,
|
||||
new_name: &str,
|
||||
) -> SourceFileEdit {
|
||||
SourceFileEdit {
|
||||
file_id,
|
||||
edit: {
|
||||
let mut builder = ra_text_edit::TextEditBuilder::default();
|
||||
builder.replace(range, new_name.into());
|
||||
builder.finish()
|
||||
},
|
||||
) -> Option<RangeInfo<(String, Definition)>> {
|
||||
if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, position.offset) {
|
||||
let def = classify_name(db, position.file_id, &name)?;
|
||||
let range = name.syntax().text_range();
|
||||
return Some(RangeInfo::new(range, (name.text().to_string(), def)));
|
||||
}
|
||||
let name_ref = find_node_at_offset::<ast::NameRef>(&syntax, position.offset)?;
|
||||
let def = classify_name_ref(db, position.file_id, &name_ref)?;
|
||||
let range = name_ref.syntax().text_range();
|
||||
Some(RangeInfo::new(range, (name_ref.text().to_string(), def)))
|
||||
}
|
||||
|
||||
fn rename_mod(
|
||||
db: &RootDatabase,
|
||||
ast_name: &ast::Name,
|
||||
ast_module: &ast::Module,
|
||||
position: FilePosition,
|
||||
new_name: &str,
|
||||
) -> Option<SourceChange> {
|
||||
let mut source_file_edits = Vec::new();
|
||||
let mut file_system_edits = Vec::new();
|
||||
let module_src = hir::Source { file_id: position.file_id.into(), ast: ast_module.clone() };
|
||||
if let Some(module) = hir::Module::from_declaration(db, module_src) {
|
||||
let src = module.definition_source(db);
|
||||
let file_id = src.file_id.original_file(db);
|
||||
match src.ast {
|
||||
ModuleSource::SourceFile(..) => {
|
||||
let mod_path: RelativePathBuf = db.file_relative_path(file_id);
|
||||
// mod is defined in path/to/dir/mod.rs
|
||||
let dst_path = if mod_path.file_stem() == Some("mod") {
|
||||
mod_path
|
||||
.parent()
|
||||
.and_then(|p| p.parent())
|
||||
.or_else(|| Some(RelativePath::new("")))
|
||||
.map(|p| p.join(new_name).join("mod.rs"))
|
||||
} else {
|
||||
Some(mod_path.with_file_name(new_name).with_extension("rs"))
|
||||
};
|
||||
if let Some(path) = dst_path {
|
||||
let move_file = FileSystemEdit::MoveFile {
|
||||
src: file_id,
|
||||
dst_source_root: db.file_source_root(position.file_id),
|
||||
dst_path: path,
|
||||
};
|
||||
file_system_edits.push(move_file);
|
||||
fn process_definition(db: &RootDatabase, def: Definition, name: String) -> Vec<FileRange> {
|
||||
let pat = name.as_str();
|
||||
let scope = def.scope(db).scope;
|
||||
let mut refs = vec![];
|
||||
|
||||
let is_match = |file_id: FileId, name_ref: &ast::NameRef| -> bool {
|
||||
let classified = classify_name_ref(db, file_id, &name_ref);
|
||||
if let Some(d) = classified {
|
||||
d == def
|
||||
} else {
|
||||
false
|
||||
}
|
||||
};
|
||||
|
||||
for (file_id, text_range) in scope {
|
||||
let text = db.file_text(file_id);
|
||||
let parse = SourceFile::parse(&text);
|
||||
let syntax = parse.tree().syntax().clone();
|
||||
|
||||
for (idx, _) in text.match_indices(pat) {
|
||||
let offset = TextUnit::from_usize(idx);
|
||||
if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&syntax, offset) {
|
||||
let range = name_ref.syntax().text_range();
|
||||
|
||||
if let Some(text_range) = text_range {
|
||||
if range.is_subrange(&text_range) && is_match(file_id, &name_ref) {
|
||||
refs.push(FileRange { file_id, range });
|
||||
}
|
||||
} else if is_match(file_id, &name_ref) {
|
||||
refs.push(FileRange { file_id, range });
|
||||
}
|
||||
}
|
||||
ModuleSource::Module(..) => {}
|
||||
}
|
||||
}
|
||||
|
||||
let edit = SourceFileEdit {
|
||||
file_id: position.file_id,
|
||||
edit: {
|
||||
let mut builder = ra_text_edit::TextEditBuilder::default();
|
||||
builder.replace(ast_name.syntax().text_range(), new_name.into());
|
||||
builder.finish()
|
||||
},
|
||||
};
|
||||
source_file_edits.push(edit);
|
||||
|
||||
Some(SourceChange::from_edits("rename", source_file_edits, file_system_edits))
|
||||
}
|
||||
|
||||
fn rename_reference(
|
||||
db: &RootDatabase,
|
||||
position: FilePosition,
|
||||
new_name: &str,
|
||||
) -> Option<RangeInfo<SourceChange>> {
|
||||
let RangeInfo { range, info: refs } = find_all_refs(db, position)?;
|
||||
|
||||
let edit = refs
|
||||
.into_iter()
|
||||
.map(|range| source_edit_from_file_id_range(range.file_id, range.range, new_name))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
if edit.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
Some(RangeInfo::new(range, SourceChange::source_file_edits("rename", edit)))
|
||||
return refs;
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::{
|
||||
mock_analysis::analysis_and_position, mock_analysis::single_file_with_position, FileId,
|
||||
mock_analysis::analysis_and_position, mock_analysis::single_file_with_position,
|
||||
ReferenceSearchResult,
|
||||
};
|
||||
use insta::assert_debug_snapshot;
|
||||
use test_utils::assert_eq_text;
|
||||
|
||||
#[test]
|
||||
fn test_find_all_refs_for_local() {
|
||||
@ -353,207 +271,4 @@ mod tests {
|
||||
let (analysis, position) = single_file_with_position(text);
|
||||
analysis.find_all_refs(position).unwrap().unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_for_local() {
|
||||
test_rename(
|
||||
r#"
|
||||
fn main() {
|
||||
let mut i = 1;
|
||||
let j = 1;
|
||||
i = i<|> + j;
|
||||
|
||||
{
|
||||
i = 0;
|
||||
}
|
||||
|
||||
i = 5;
|
||||
}"#,
|
||||
"k",
|
||||
r#"
|
||||
fn main() {
|
||||
let mut k = 1;
|
||||
let j = 1;
|
||||
k = k + j;
|
||||
|
||||
{
|
||||
k = 0;
|
||||
}
|
||||
|
||||
k = 5;
|
||||
}"#,
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_for_param_inside() {
|
||||
test_rename(
|
||||
r#"
|
||||
fn foo(i : u32) -> u32 {
|
||||
i<|>
|
||||
}"#,
|
||||
"j",
|
||||
r#"
|
||||
fn foo(j : u32) -> u32 {
|
||||
j
|
||||
}"#,
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_refs_for_fn_param() {
|
||||
test_rename(
|
||||
r#"
|
||||
fn foo(i<|> : u32) -> u32 {
|
||||
i
|
||||
}"#,
|
||||
"new_name",
|
||||
r#"
|
||||
fn foo(new_name : u32) -> u32 {
|
||||
new_name
|
||||
}"#,
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_for_mut_param() {
|
||||
test_rename(
|
||||
r#"
|
||||
fn foo(mut i<|> : u32) -> u32 {
|
||||
i
|
||||
}"#,
|
||||
"new_name",
|
||||
r#"
|
||||
fn foo(mut new_name : u32) -> u32 {
|
||||
new_name
|
||||
}"#,
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_mod() {
|
||||
let (analysis, position) = analysis_and_position(
|
||||
"
|
||||
//- /lib.rs
|
||||
mod bar;
|
||||
|
||||
//- /bar.rs
|
||||
mod foo<|>;
|
||||
|
||||
//- /bar/foo.rs
|
||||
// emtpy
|
||||
",
|
||||
);
|
||||
let new_name = "foo2";
|
||||
let source_change = analysis.rename(position, new_name).unwrap();
|
||||
assert_debug_snapshot!(&source_change,
|
||||
@r###"
|
||||
Some(
|
||||
RangeInfo {
|
||||
range: [4; 7),
|
||||
info: SourceChange {
|
||||
label: "rename",
|
||||
source_file_edits: [
|
||||
SourceFileEdit {
|
||||
file_id: FileId(
|
||||
2,
|
||||
),
|
||||
edit: TextEdit {
|
||||
atoms: [
|
||||
AtomTextEdit {
|
||||
delete: [4; 7),
|
||||
insert: "foo2",
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
file_system_edits: [
|
||||
MoveFile {
|
||||
src: FileId(
|
||||
3,
|
||||
),
|
||||
dst_source_root: SourceRootId(
|
||||
0,
|
||||
),
|
||||
dst_path: "bar/foo2.rs",
|
||||
},
|
||||
],
|
||||
cursor_position: None,
|
||||
},
|
||||
},
|
||||
)
|
||||
"###);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_mod_in_dir() {
|
||||
let (analysis, position) = analysis_and_position(
|
||||
"
|
||||
//- /lib.rs
|
||||
mod fo<|>o;
|
||||
//- /foo/mod.rs
|
||||
// emtpy
|
||||
",
|
||||
);
|
||||
let new_name = "foo2";
|
||||
let source_change = analysis.rename(position, new_name).unwrap();
|
||||
assert_debug_snapshot!(&source_change,
|
||||
@r###"
|
||||
Some(
|
||||
RangeInfo {
|
||||
range: [4; 7),
|
||||
info: SourceChange {
|
||||
label: "rename",
|
||||
source_file_edits: [
|
||||
SourceFileEdit {
|
||||
file_id: FileId(
|
||||
1,
|
||||
),
|
||||
edit: TextEdit {
|
||||
atoms: [
|
||||
AtomTextEdit {
|
||||
delete: [4; 7),
|
||||
insert: "foo2",
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
file_system_edits: [
|
||||
MoveFile {
|
||||
src: FileId(
|
||||
2,
|
||||
),
|
||||
dst_source_root: SourceRootId(
|
||||
0,
|
||||
),
|
||||
dst_path: "foo2/mod.rs",
|
||||
},
|
||||
],
|
||||
cursor_position: None,
|
||||
},
|
||||
},
|
||||
)
|
||||
"###
|
||||
);
|
||||
}
|
||||
|
||||
fn test_rename(text: &str, new_name: &str, expected: &str) {
|
||||
let (analysis, position) = single_file_with_position(text);
|
||||
let source_change = analysis.rename(position, new_name).unwrap();
|
||||
let mut text_edit_builder = ra_text_edit::TextEditBuilder::default();
|
||||
let mut file_id: Option<FileId> = None;
|
||||
if let Some(change) = source_change {
|
||||
for edit in change.info.source_file_edits {
|
||||
file_id = Some(edit.file_id);
|
||||
for atom in edit.edit.as_atoms() {
|
||||
text_edit_builder.replace(atom.delete, atom.insert.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
let result =
|
||||
text_edit_builder.finish().apply(&*analysis.file_text(file_id.unwrap()).unwrap());
|
||||
assert_eq_text!(expected, &*result);
|
||||
}
|
||||
}
|
||||
|
||||
143
crates/ra_ide_api/src/references/classify.rs
Normal file
143
crates/ra_ide_api/src/references/classify.rs
Normal file
@ -0,0 +1,143 @@
|
||||
use hir::{
|
||||
AssocItem, Either, EnumVariant, FromSource, Module, ModuleDef, ModuleSource, Path,
|
||||
PathResolution, Source, SourceAnalyzer, StructField,
|
||||
};
|
||||
use ra_db::FileId;
|
||||
use ra_syntax::{ast, match_ast, AstNode, AstPtr};
|
||||
|
||||
use super::{definition::HasDefinition, Definition, NameKind};
|
||||
use crate::db::RootDatabase;
|
||||
|
||||
use hir::{db::AstDatabase, HirFileId};
|
||||
|
||||
pub(crate) fn classify_name(
|
||||
db: &RootDatabase,
|
||||
file_id: FileId,
|
||||
name: &ast::Name,
|
||||
) -> Option<Definition> {
|
||||
let parent = name.syntax().parent()?;
|
||||
let file_id = file_id.into();
|
||||
|
||||
match_ast! {
|
||||
match parent {
|
||||
ast::BindPat(it) => {
|
||||
decl_from_pat(db, file_id, AstPtr::new(&it))
|
||||
},
|
||||
ast::RecordFieldDef(it) => {
|
||||
StructField::from_def(db, file_id, it)
|
||||
},
|
||||
ast::ImplItem(it) => {
|
||||
AssocItem::from_def(db, file_id, it.clone()).or_else(|| {
|
||||
match it {
|
||||
ast::ImplItem::FnDef(f) => ModuleDef::from_def(db, file_id, f.into()),
|
||||
ast::ImplItem::ConstDef(c) => ModuleDef::from_def(db, file_id, c.into()),
|
||||
ast::ImplItem::TypeAliasDef(a) => ModuleDef::from_def(db, file_id, a.into()),
|
||||
}
|
||||
})
|
||||
},
|
||||
ast::EnumVariant(it) => {
|
||||
let src = hir::Source { file_id, ast: it.clone() };
|
||||
let def: ModuleDef = EnumVariant::from_source(db, src)?.into();
|
||||
Some(def.definition(db))
|
||||
},
|
||||
ast::ModuleItem(it) => {
|
||||
ModuleDef::from_def(db, file_id, it)
|
||||
},
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn classify_name_ref(
|
||||
db: &RootDatabase,
|
||||
file_id: FileId,
|
||||
name_ref: &ast::NameRef,
|
||||
) -> Option<Definition> {
|
||||
let analyzer = SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
|
||||
let parent = name_ref.syntax().parent()?;
|
||||
match_ast! {
|
||||
match parent {
|
||||
ast::MethodCallExpr(it) => {
|
||||
return AssocItem::from_ref(db, &analyzer, it);
|
||||
},
|
||||
ast::FieldExpr(it) => {
|
||||
if let Some(field) = analyzer.resolve_field(&it) {
|
||||
return Some(field.definition(db));
|
||||
}
|
||||
},
|
||||
ast::RecordField(it) => {
|
||||
if let Some(record_lit) = it.syntax().ancestors().find_map(ast::RecordLit::cast) {
|
||||
let variant_def = analyzer.resolve_record_literal(&record_lit)?;
|
||||
let hir_path = Path::from_name_ref(name_ref);
|
||||
let hir_name = hir_path.as_ident()?;
|
||||
let field = variant_def.field(db, hir_name)?;
|
||||
return Some(field.definition(db));
|
||||
}
|
||||
},
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
|
||||
let ast = ModuleSource::from_child_node(db, file_id, &parent);
|
||||
let file_id = file_id.into();
|
||||
let container = Module::from_definition(db, Source { file_id, ast })?;
|
||||
let visibility = None;
|
||||
|
||||
if let Some(macro_call) =
|
||||
parent.parent().and_then(|node| node.parent()).and_then(ast::MacroCall::cast)
|
||||
{
|
||||
if let Some(mac) = analyzer.resolve_macro_call(db, ¯o_call) {
|
||||
return Some(Definition { item: NameKind::Macro(mac), container, visibility });
|
||||
}
|
||||
}
|
||||
|
||||
// General case, a path or a local:
|
||||
let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
|
||||
let resolved = analyzer.resolve_path(db, &path)?;
|
||||
match resolved {
|
||||
PathResolution::Def(def) => Some(def.definition(db)),
|
||||
PathResolution::LocalBinding(Either::A(pat)) => decl_from_pat(db, file_id, pat),
|
||||
PathResolution::LocalBinding(Either::B(par)) => {
|
||||
Some(Definition { item: NameKind::SelfParam(par), container, visibility })
|
||||
}
|
||||
PathResolution::GenericParam(par) => {
|
||||
// FIXME: get generic param def
|
||||
Some(Definition { item: NameKind::GenericParam(par), container, visibility })
|
||||
}
|
||||
PathResolution::Macro(def) => {
|
||||
Some(Definition { item: NameKind::Macro(def), container, visibility })
|
||||
}
|
||||
PathResolution::SelfType(impl_block) => {
|
||||
let ty = impl_block.target_ty(db);
|
||||
let container = impl_block.module();
|
||||
Some(Definition { item: NameKind::SelfType(ty), container, visibility })
|
||||
}
|
||||
PathResolution::AssocItem(assoc) => Some(assoc.definition(db)),
|
||||
}
|
||||
}
|
||||
|
||||
fn decl_from_pat(
|
||||
db: &RootDatabase,
|
||||
file_id: HirFileId,
|
||||
pat: AstPtr<ast::BindPat>,
|
||||
) -> Option<Definition> {
|
||||
let root = db.parse_or_expand(file_id)?;
|
||||
// FIXME: use match_ast!
|
||||
let def = pat.to_node(&root).syntax().ancestors().find_map(|node| {
|
||||
if let Some(it) = ast::FnDef::cast(node.clone()) {
|
||||
let src = hir::Source { file_id, ast: it };
|
||||
Some(hir::Function::from_source(db, src)?.into())
|
||||
} else if let Some(it) = ast::ConstDef::cast(node.clone()) {
|
||||
let src = hir::Source { file_id, ast: it };
|
||||
Some(hir::Const::from_source(db, src)?.into())
|
||||
} else if let Some(it) = ast::StaticDef::cast(node.clone()) {
|
||||
let src = hir::Source { file_id, ast: it };
|
||||
Some(hir::Static::from_source(db, src)?.into())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})?;
|
||||
let item = NameKind::Pat((def, pat));
|
||||
let container = def.module(db);
|
||||
Some(Definition { item, container, visibility: None })
|
||||
}
|
||||
177
crates/ra_ide_api/src/references/definition.rs
Normal file
177
crates/ra_ide_api/src/references/definition.rs
Normal file
@ -0,0 +1,177 @@
|
||||
use hir::{
|
||||
db::AstDatabase, Adt, AssocItem, DefWithBody, FromSource, HasSource, HirFileId, MacroDef,
|
||||
Module, ModuleDef, SourceAnalyzer, StructField, Ty, VariantDef,
|
||||
};
|
||||
use ra_syntax::{ast, ast::VisibilityOwner, AstNode, AstPtr};
|
||||
|
||||
use crate::db::RootDatabase;
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub enum NameKind {
|
||||
Macro(MacroDef),
|
||||
FieldAccess(StructField),
|
||||
AssocItem(AssocItem),
|
||||
Def(ModuleDef),
|
||||
SelfType(Ty),
|
||||
Pat((DefWithBody, AstPtr<ast::BindPat>)),
|
||||
SelfParam(AstPtr<ast::SelfParam>),
|
||||
GenericParam(u32),
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Eq)]
|
||||
pub(crate) struct Definition {
|
||||
pub visibility: Option<ast::Visibility>,
|
||||
pub container: Module,
|
||||
pub item: NameKind,
|
||||
}
|
||||
|
||||
pub(super) trait HasDefinition {
|
||||
type Def;
|
||||
type Ref;
|
||||
|
||||
fn definition(self, db: &RootDatabase) -> Definition;
|
||||
fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Definition>;
|
||||
fn from_ref(
|
||||
db: &RootDatabase,
|
||||
analyzer: &SourceAnalyzer,
|
||||
refer: Self::Ref,
|
||||
) -> Option<Definition>;
|
||||
}
|
||||
|
||||
// fn decl_from_pat(
|
||||
// db: &RootDatabase,
|
||||
// file_id: HirFileId,
|
||||
// pat: AstPtr<ast::BindPat>,
|
||||
// ) -> Option<Definition> {
|
||||
// let root = db.parse_or_expand(file_id)?;
|
||||
// // FIXME: use match_ast!
|
||||
// let def = pat.to_node(&root).syntax().ancestors().find_map(|node| {
|
||||
// if let Some(it) = ast::FnDef::cast(node.clone()) {
|
||||
// let src = hir::Source { file_id, ast: it };
|
||||
// Some(hir::Function::from_source(db, src)?.into())
|
||||
// } else if let Some(it) = ast::ConstDef::cast(node.clone()) {
|
||||
// let src = hir::Source { file_id, ast: it };
|
||||
// Some(hir::Const::from_source(db, src)?.into())
|
||||
// } else if let Some(it) = ast::StaticDef::cast(node.clone()) {
|
||||
// let src = hir::Source { file_id, ast: it };
|
||||
// Some(hir::Static::from_source(db, src)?.into())
|
||||
// } else {
|
||||
// None
|
||||
// }
|
||||
// })?;
|
||||
// let item = NameKind::Pat((def, pat));
|
||||
// let container = def.module(db);
|
||||
// Some(Definition { item, container, visibility: None })
|
||||
// }
|
||||
|
||||
impl HasDefinition for StructField {
|
||||
type Def = ast::RecordFieldDef;
|
||||
type Ref = ast::FieldExpr;
|
||||
|
||||
fn definition(self, db: &RootDatabase) -> Definition {
|
||||
let item = NameKind::FieldAccess(self);
|
||||
let parent = self.parent_def(db);
|
||||
let container = parent.module(db);
|
||||
let visibility = match parent {
|
||||
VariantDef::Struct(s) => s.source(db).ast.visibility(),
|
||||
VariantDef::EnumVariant(e) => e.source(db).ast.parent_enum().visibility(),
|
||||
};
|
||||
Definition { item, container, visibility }
|
||||
}
|
||||
|
||||
fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Definition> {
|
||||
let src = hir::Source { file_id, ast: hir::FieldSource::Named(def) };
|
||||
let field = StructField::from_source(db, src)?;
|
||||
Some(field.definition(db))
|
||||
}
|
||||
|
||||
fn from_ref(
|
||||
db: &RootDatabase,
|
||||
analyzer: &SourceAnalyzer,
|
||||
refer: Self::Ref,
|
||||
) -> Option<Definition> {
|
||||
let field = analyzer.resolve_field(&refer)?;
|
||||
Some(field.definition(db))
|
||||
}
|
||||
}
|
||||
|
||||
impl HasDefinition for AssocItem {
|
||||
type Def = ast::ImplItem;
|
||||
type Ref = ast::MethodCallExpr;
|
||||
|
||||
fn definition(self, db: &RootDatabase) -> Definition {
|
||||
let item = NameKind::AssocItem(self);
|
||||
let container = self.module(db);
|
||||
let visibility = match self {
|
||||
AssocItem::Function(f) => f.source(db).ast.visibility(),
|
||||
AssocItem::Const(c) => c.source(db).ast.visibility(),
|
||||
AssocItem::TypeAlias(a) => a.source(db).ast.visibility(),
|
||||
};
|
||||
Definition { item, container, visibility }
|
||||
}
|
||||
|
||||
fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Definition> {
|
||||
if def.syntax().parent().and_then(ast::ItemList::cast).is_none() {
|
||||
return None;
|
||||
}
|
||||
let src = hir::Source { file_id, ast: def };
|
||||
let item = AssocItem::from_source(db, src)?;
|
||||
Some(item.definition(db))
|
||||
}
|
||||
|
||||
fn from_ref(
|
||||
db: &RootDatabase,
|
||||
analyzer: &SourceAnalyzer,
|
||||
refer: Self::Ref,
|
||||
) -> Option<Definition> {
|
||||
let func: AssocItem = analyzer.resolve_method_call(&refer)?.into();
|
||||
Some(func.definition(db))
|
||||
}
|
||||
}
|
||||
|
||||
impl HasDefinition for ModuleDef {
|
||||
type Def = ast::ModuleItem;
|
||||
type Ref = ast::Path;
|
||||
|
||||
fn definition(self, db: &RootDatabase) -> Definition {
|
||||
let (container, visibility) = match self {
|
||||
ModuleDef::Module(it) => {
|
||||
let container = it.parent(db).or_else(|| Some(it)).unwrap();
|
||||
let visibility = it.declaration_source(db).and_then(|s| s.ast.visibility());
|
||||
(container, visibility)
|
||||
}
|
||||
ModuleDef::EnumVariant(it) => {
|
||||
let container = it.module(db);
|
||||
let visibility = it.source(db).ast.parent_enum().visibility();
|
||||
(container, visibility)
|
||||
}
|
||||
ModuleDef::Function(it) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Const(it) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Static(it) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Trait(it) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::TypeAlias(it) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Adt(Adt::Struct(it)) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Adt(Adt::Union(it)) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::Adt(Adt::Enum(it)) => (it.module(db), it.source(db).ast.visibility()),
|
||||
ModuleDef::BuiltinType(..) => unreachable!(),
|
||||
};
|
||||
let item = NameKind::Def(self);
|
||||
Definition { item, container, visibility }
|
||||
}
|
||||
|
||||
fn from_def(db: &RootDatabase, file_id: HirFileId, def: Self::Def) -> Option<Definition> {
|
||||
let src = hir::Source { file_id, ast: def };
|
||||
let def = ModuleDef::from_source(db, src)?;
|
||||
Some(def.definition(db))
|
||||
}
|
||||
|
||||
fn from_ref(
|
||||
db: &RootDatabase,
|
||||
analyzer: &SourceAnalyzer,
|
||||
refer: Self::Ref,
|
||||
) -> Option<Definition> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: impl HasDefinition for hir::MacroDef
|
||||
467
crates/ra_ide_api/src/references/rename.rs
Normal file
467
crates/ra_ide_api/src/references/rename.rs
Normal file
@ -0,0 +1,467 @@
|
||||
use hir::ModuleSource;
|
||||
use ra_db::SourceDatabase;
|
||||
use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SyntaxNode};
|
||||
use relative_path::{RelativePath, RelativePathBuf};
|
||||
|
||||
use crate::{
|
||||
db::RootDatabase, FileId, FilePosition, FileSystemEdit, RangeInfo, SourceChange,
|
||||
SourceFileEdit, TextRange,
|
||||
};
|
||||
|
||||
use super::find_all_refs;
|
||||
|
||||
pub(crate) fn rename(
|
||||
db: &RootDatabase,
|
||||
position: FilePosition,
|
||||
new_name: &str,
|
||||
) -> Option<RangeInfo<SourceChange>> {
|
||||
let parse = db.parse(position.file_id);
|
||||
if let Some((ast_name, ast_module)) =
|
||||
find_name_and_module_at_offset(parse.tree().syntax(), position)
|
||||
{
|
||||
let range = ast_name.syntax().text_range();
|
||||
rename_mod(db, &ast_name, &ast_module, position, new_name)
|
||||
.map(|info| RangeInfo::new(range, info))
|
||||
} else {
|
||||
rename_reference(db, position, new_name)
|
||||
}
|
||||
}
|
||||
|
||||
fn find_name_and_module_at_offset(
|
||||
syntax: &SyntaxNode,
|
||||
position: FilePosition,
|
||||
) -> Option<(ast::Name, ast::Module)> {
|
||||
let ast_name = find_node_at_offset::<ast::Name>(syntax, position.offset)?;
|
||||
let ast_module = ast::Module::cast(ast_name.syntax().parent()?)?;
|
||||
Some((ast_name, ast_module))
|
||||
}
|
||||
|
||||
fn source_edit_from_file_id_range(
|
||||
file_id: FileId,
|
||||
range: TextRange,
|
||||
new_name: &str,
|
||||
) -> SourceFileEdit {
|
||||
SourceFileEdit {
|
||||
file_id,
|
||||
edit: {
|
||||
let mut builder = ra_text_edit::TextEditBuilder::default();
|
||||
builder.replace(range, new_name.into());
|
||||
builder.finish()
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn rename_mod(
|
||||
db: &RootDatabase,
|
||||
ast_name: &ast::Name,
|
||||
ast_module: &ast::Module,
|
||||
position: FilePosition,
|
||||
new_name: &str,
|
||||
) -> Option<SourceChange> {
|
||||
let mut source_file_edits = Vec::new();
|
||||
let mut file_system_edits = Vec::new();
|
||||
let module_src = hir::Source { file_id: position.file_id.into(), ast: ast_module.clone() };
|
||||
if let Some(module) = hir::Module::from_declaration(db, module_src) {
|
||||
let src = module.definition_source(db);
|
||||
let file_id = src.file_id.original_file(db);
|
||||
match src.ast {
|
||||
ModuleSource::SourceFile(..) => {
|
||||
let mod_path: RelativePathBuf = db.file_relative_path(file_id);
|
||||
// mod is defined in path/to/dir/mod.rs
|
||||
let dst_path = if mod_path.file_stem() == Some("mod") {
|
||||
mod_path
|
||||
.parent()
|
||||
.and_then(|p| p.parent())
|
||||
.or_else(|| Some(RelativePath::new("")))
|
||||
.map(|p| p.join(new_name).join("mod.rs"))
|
||||
} else {
|
||||
Some(mod_path.with_file_name(new_name).with_extension("rs"))
|
||||
};
|
||||
if let Some(path) = dst_path {
|
||||
let move_file = FileSystemEdit::MoveFile {
|
||||
src: file_id,
|
||||
dst_source_root: db.file_source_root(position.file_id),
|
||||
dst_path: path,
|
||||
};
|
||||
file_system_edits.push(move_file);
|
||||
}
|
||||
}
|
||||
ModuleSource::Module(..) => {}
|
||||
}
|
||||
}
|
||||
|
||||
let edit = SourceFileEdit {
|
||||
file_id: position.file_id,
|
||||
edit: {
|
||||
let mut builder = ra_text_edit::TextEditBuilder::default();
|
||||
builder.replace(ast_name.syntax().text_range(), new_name.into());
|
||||
builder.finish()
|
||||
},
|
||||
};
|
||||
source_file_edits.push(edit);
|
||||
|
||||
Some(SourceChange::from_edits("rename", source_file_edits, file_system_edits))
|
||||
}
|
||||
|
||||
fn rename_reference(
|
||||
db: &RootDatabase,
|
||||
position: FilePosition,
|
||||
new_name: &str,
|
||||
) -> Option<RangeInfo<SourceChange>> {
|
||||
let RangeInfo { range, info: refs } = find_all_refs(db, position)?;
|
||||
|
||||
let edit = refs
|
||||
.into_iter()
|
||||
.map(|range| source_edit_from_file_id_range(range.file_id, range.range, new_name))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
if edit.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
Some(RangeInfo::new(range, SourceChange::source_file_edits("rename", edit)))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::{
|
||||
mock_analysis::analysis_and_position, mock_analysis::single_file_with_position, FileId,
|
||||
ReferenceSearchResult,
|
||||
};
|
||||
use insta::assert_debug_snapshot;
|
||||
use test_utils::assert_eq_text;
|
||||
|
||||
#[test]
|
||||
fn test_find_all_refs_for_local() {
|
||||
let code = r#"
|
||||
fn main() {
|
||||
let mut i = 1;
|
||||
let j = 1;
|
||||
i = i<|> + j;
|
||||
|
||||
{
|
||||
i = 0;
|
||||
}
|
||||
|
||||
i = 5;
|
||||
}"#;
|
||||
|
||||
let refs = get_all_refs(code);
|
||||
assert_eq!(refs.len(), 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_find_all_refs_for_param_inside() {
|
||||
let code = r#"
|
||||
fn foo(i : u32) -> u32 {
|
||||
i<|>
|
||||
}"#;
|
||||
|
||||
let refs = get_all_refs(code);
|
||||
assert_eq!(refs.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_find_all_refs_for_fn_param() {
|
||||
let code = r#"
|
||||
fn foo(i<|> : u32) -> u32 {
|
||||
i
|
||||
}"#;
|
||||
|
||||
let refs = get_all_refs(code);
|
||||
assert_eq!(refs.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_find_all_refs_field_name() {
|
||||
let code = r#"
|
||||
//- /lib.rs
|
||||
struct Foo {
|
||||
pub spam<|>: u32,
|
||||
}
|
||||
|
||||
fn main(s: Foo) {
|
||||
let f = s.spam;
|
||||
}
|
||||
"#;
|
||||
|
||||
let refs = get_all_refs(code);
|
||||
assert_eq!(refs.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_find_all_refs_impl_item_name() {
|
||||
let code = r#"
|
||||
//- /lib.rs
|
||||
struct Foo;
|
||||
impl Foo {
|
||||
fn f<|>(&self) { }
|
||||
}
|
||||
"#;
|
||||
|
||||
let refs = get_all_refs(code);
|
||||
assert_eq!(refs.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_find_all_refs_enum_var_name() {
|
||||
let code = r#"
|
||||
//- /lib.rs
|
||||
enum Foo {
|
||||
A,
|
||||
B<|>,
|
||||
C,
|
||||
}
|
||||
"#;
|
||||
|
||||
let refs = get_all_refs(code);
|
||||
assert_eq!(refs.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_find_all_refs_modules() {
|
||||
let code = r#"
|
||||
//- /lib.rs
|
||||
pub mod foo;
|
||||
pub mod bar;
|
||||
|
||||
fn f() {
|
||||
let i = foo::Foo { n: 5 };
|
||||
}
|
||||
|
||||
//- /foo.rs
|
||||
use crate::bar;
|
||||
|
||||
pub struct Foo {
|
||||
pub n: u32,
|
||||
}
|
||||
|
||||
fn f() {
|
||||
let i = bar::Bar { n: 5 };
|
||||
}
|
||||
|
||||
//- /bar.rs
|
||||
use crate::foo;
|
||||
|
||||
pub struct Bar {
|
||||
pub n: u32,
|
||||
}
|
||||
|
||||
fn f() {
|
||||
let i = foo::Foo<|> { n: 5 };
|
||||
}
|
||||
"#;
|
||||
|
||||
let (analysis, pos) = analysis_and_position(code);
|
||||
let refs = analysis.find_all_refs(pos).unwrap().unwrap();
|
||||
assert_eq!(refs.len(), 3);
|
||||
}
|
||||
|
||||
fn get_all_refs(text: &str) -> ReferenceSearchResult {
|
||||
let (analysis, position) = single_file_with_position(text);
|
||||
analysis.find_all_refs(position).unwrap().unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_for_local() {
|
||||
test_rename(
|
||||
r#"
|
||||
fn main() {
|
||||
let mut i = 1;
|
||||
let j = 1;
|
||||
i = i<|> + j;
|
||||
|
||||
{
|
||||
i = 0;
|
||||
}
|
||||
|
||||
i = 5;
|
||||
}"#,
|
||||
"k",
|
||||
r#"
|
||||
fn main() {
|
||||
let mut k = 1;
|
||||
let j = 1;
|
||||
k = k + j;
|
||||
|
||||
{
|
||||
k = 0;
|
||||
}
|
||||
|
||||
k = 5;
|
||||
}"#,
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_for_param_inside() {
|
||||
test_rename(
|
||||
r#"
|
||||
fn foo(i : u32) -> u32 {
|
||||
i<|>
|
||||
}"#,
|
||||
"j",
|
||||
r#"
|
||||
fn foo(j : u32) -> u32 {
|
||||
j
|
||||
}"#,
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_refs_for_fn_param() {
|
||||
test_rename(
|
||||
r#"
|
||||
fn foo(i<|> : u32) -> u32 {
|
||||
i
|
||||
}"#,
|
||||
"new_name",
|
||||
r#"
|
||||
fn foo(new_name : u32) -> u32 {
|
||||
new_name
|
||||
}"#,
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_for_mut_param() {
|
||||
test_rename(
|
||||
r#"
|
||||
fn foo(mut i<|> : u32) -> u32 {
|
||||
i
|
||||
}"#,
|
||||
"new_name",
|
||||
r#"
|
||||
fn foo(mut new_name : u32) -> u32 {
|
||||
new_name
|
||||
}"#,
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_mod() {
|
||||
let (analysis, position) = analysis_and_position(
|
||||
"
|
||||
//- /lib.rs
|
||||
mod bar;
|
||||
|
||||
//- /bar.rs
|
||||
mod foo<|>;
|
||||
|
||||
//- /bar/foo.rs
|
||||
// emtpy
|
||||
",
|
||||
);
|
||||
let new_name = "foo2";
|
||||
let source_change = analysis.rename(position, new_name).unwrap();
|
||||
assert_debug_snapshot!(&source_change,
|
||||
@r###"
|
||||
Some(
|
||||
RangeInfo {
|
||||
range: [4; 7),
|
||||
info: SourceChange {
|
||||
label: "rename",
|
||||
source_file_edits: [
|
||||
SourceFileEdit {
|
||||
file_id: FileId(
|
||||
2,
|
||||
),
|
||||
edit: TextEdit {
|
||||
atoms: [
|
||||
AtomTextEdit {
|
||||
delete: [4; 7),
|
||||
insert: "foo2",
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
file_system_edits: [
|
||||
MoveFile {
|
||||
src: FileId(
|
||||
3,
|
||||
),
|
||||
dst_source_root: SourceRootId(
|
||||
0,
|
||||
),
|
||||
dst_path: "bar/foo2.rs",
|
||||
},
|
||||
],
|
||||
cursor_position: None,
|
||||
},
|
||||
},
|
||||
)
|
||||
"###);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rename_mod_in_dir() {
|
||||
let (analysis, position) = analysis_and_position(
|
||||
"
|
||||
//- /lib.rs
|
||||
mod fo<|>o;
|
||||
//- /foo/mod.rs
|
||||
// emtpy
|
||||
",
|
||||
);
|
||||
let new_name = "foo2";
|
||||
let source_change = analysis.rename(position, new_name).unwrap();
|
||||
assert_debug_snapshot!(&source_change,
|
||||
@r###"
|
||||
Some(
|
||||
RangeInfo {
|
||||
range: [4; 7),
|
||||
info: SourceChange {
|
||||
label: "rename",
|
||||
source_file_edits: [
|
||||
SourceFileEdit {
|
||||
file_id: FileId(
|
||||
1,
|
||||
),
|
||||
edit: TextEdit {
|
||||
atoms: [
|
||||
AtomTextEdit {
|
||||
delete: [4; 7),
|
||||
insert: "foo2",
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
file_system_edits: [
|
||||
MoveFile {
|
||||
src: FileId(
|
||||
2,
|
||||
),
|
||||
dst_source_root: SourceRootId(
|
||||
0,
|
||||
),
|
||||
dst_path: "foo2/mod.rs",
|
||||
},
|
||||
],
|
||||
cursor_position: None,
|
||||
},
|
||||
},
|
||||
)
|
||||
"###
|
||||
);
|
||||
}
|
||||
|
||||
fn test_rename(text: &str, new_name: &str, expected: &str) {
|
||||
let (analysis, position) = single_file_with_position(text);
|
||||
let source_change = analysis.rename(position, new_name).unwrap();
|
||||
let mut text_edit_builder = ra_text_edit::TextEditBuilder::default();
|
||||
let mut file_id: Option<FileId> = None;
|
||||
if let Some(change) = source_change {
|
||||
for edit in change.info.source_file_edits {
|
||||
file_id = Some(edit.file_id);
|
||||
for atom in edit.edit.as_atoms() {
|
||||
text_edit_builder.replace(atom.delete, atom.insert.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
let result =
|
||||
text_edit_builder.finish().apply(&*analysis.file_text(file_id.unwrap()).unwrap());
|
||||
assert_eq_text!(expected, &*result);
|
||||
}
|
||||
}
|
||||
@ -1,55 +1,15 @@
|
||||
use hir::{DefWithBody, HasSource, ModuleSource, SourceAnalyzer};
|
||||
use ra_db::{FileId, FileRange, SourceDatabase};
|
||||
use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, TextRange, TextUnit};
|
||||
use hir::{DefWithBody, HasSource, ModuleSource};
|
||||
use ra_db::{FileId, SourceDatabase};
|
||||
use ra_syntax::{AstNode, TextRange};
|
||||
|
||||
use crate::{
|
||||
db::RootDatabase,
|
||||
name_kind::{classify_name_ref, Definition, NameKind},
|
||||
};
|
||||
use crate::db::RootDatabase;
|
||||
|
||||
use super::{Definition, NameKind};
|
||||
|
||||
pub(crate) struct SearchScope {
|
||||
pub scope: Vec<(FileId, Option<TextRange>)>,
|
||||
}
|
||||
|
||||
pub(crate) fn find_refs(db: &RootDatabase, def: Definition, name: String) -> Vec<FileRange> {
|
||||
let pat = name.as_str();
|
||||
let scope = def.scope(db).scope;
|
||||
let mut refs = vec![];
|
||||
|
||||
let is_match = |file_id: FileId, name_ref: &ast::NameRef| -> bool {
|
||||
let analyzer = SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
|
||||
let classified = classify_name_ref(db, file_id, &analyzer, &name_ref);
|
||||
if let Some(d) = classified {
|
||||
d == def
|
||||
} else {
|
||||
false
|
||||
}
|
||||
};
|
||||
|
||||
for (file_id, text_range) in scope {
|
||||
let text = db.file_text(file_id);
|
||||
let parse = SourceFile::parse(&text);
|
||||
let syntax = parse.tree().syntax().clone();
|
||||
|
||||
for (idx, _) in text.match_indices(pat) {
|
||||
let offset = TextUnit::from_usize(idx);
|
||||
if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&syntax, offset) {
|
||||
let range = name_ref.syntax().text_range();
|
||||
|
||||
if let Some(text_range) = text_range {
|
||||
if range.is_subrange(&text_range) && is_match(file_id, &name_ref) {
|
||||
refs.push(FileRange { file_id, range });
|
||||
}
|
||||
} else if is_match(file_id, &name_ref) {
|
||||
refs.push(FileRange { file_id, range });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return refs;
|
||||
}
|
||||
|
||||
impl Definition {
|
||||
pub fn scope(&self, db: &RootDatabase) -> SearchScope {
|
||||
let module_src = self.container.definition_source(db);
|
||||
@ -14,7 +14,7 @@ use ra_syntax::{
|
||||
|
||||
use crate::{
|
||||
db::RootDatabase,
|
||||
name_kind::{classify_name_ref, NameKind::*},
|
||||
references::{classify_name_ref, NameKind::*},
|
||||
FileId,
|
||||
};
|
||||
|
||||
@ -101,10 +101,8 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
|
||||
continue;
|
||||
}
|
||||
if let Some(name_ref) = node.as_node().cloned().and_then(ast::NameRef::cast) {
|
||||
// FIXME: try to reuse the SourceAnalyzers
|
||||
let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
|
||||
let name_kind = classify_name_ref(db, file_id, &analyzer, &name_ref)
|
||||
.and_then(|d| Some(d.item));
|
||||
let name_kind =
|
||||
classify_name_ref(db, file_id, &name_ref).and_then(|d| Some(d.item));
|
||||
match name_kind {
|
||||
Some(Macro(_)) => "macro",
|
||||
Some(FieldAccess(_)) => "field",
|
||||
@ -131,6 +129,8 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
|
||||
Some(calc_binding_hash(file_id, &text, *shadow_count))
|
||||
}
|
||||
|
||||
let analyzer =
|
||||
hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
|
||||
if is_variable_mutable(db, &analyzer, ptr.to_node(&root)) {
|
||||
"variable.mut"
|
||||
} else {
|
||||
|
||||
@ -481,7 +481,7 @@ pub fn handle_references(
|
||||
params: req::ReferenceParams,
|
||||
) -> Result<Option<Vec<Location>>> {
|
||||
let position = params.text_document_position.try_conv_with(&world)?;
|
||||
|
||||
|
||||
let refs = match world.analysis().find_all_refs(position)? {
|
||||
None => return Ok(None),
|
||||
Some(refs) => refs,
|
||||
|
||||
Loading…
Reference in New Issue
Block a user