905 lines
32 KiB
Rust
905 lines
32 KiB
Rust
//! See [`NavigationTarget`].
|
|
|
|
use std::fmt;
|
|
|
|
use arrayvec::ArrayVec;
|
|
use either::Either;
|
|
use hir::{
|
|
db::ExpandDatabase, symbols::FileSymbol, AssocItem, FieldSource, HasContainer, HasSource,
|
|
HirDisplay, HirFileId, InFile, LocalSource, ModuleSource,
|
|
};
|
|
use ide_db::{
|
|
base_db::{FileId, FileRange},
|
|
defs::Definition,
|
|
documentation::{Documentation, HasDocs},
|
|
RootDatabase, SymbolKind,
|
|
};
|
|
use stdx::never;
|
|
use syntax::{
|
|
ast::{self, HasName},
|
|
format_smolstr, AstNode, SmolStr, SyntaxNode, TextRange,
|
|
};
|
|
|
|
/// `NavigationTarget` represents an element in the editor's UI which you can
|
|
/// click on to navigate to a particular piece of code.
|
|
///
|
|
/// Typically, a `NavigationTarget` corresponds to some element in the source
|
|
/// code, like a function or a struct, but this is not strictly required.
|
|
#[derive(Clone, PartialEq, Eq, Hash)]
|
|
pub struct NavigationTarget {
|
|
pub file_id: FileId,
|
|
/// Range which encompasses the whole element.
|
|
///
|
|
/// Should include body, doc comments, attributes, etc.
|
|
///
|
|
/// Clients should use this range to answer "is the cursor inside the
|
|
/// element?" question.
|
|
pub full_range: TextRange,
|
|
/// A "most interesting" range within the `full_range`.
|
|
///
|
|
/// Typically, `full_range` is the whole syntax node, including doc
|
|
/// comments, and `focus_range` is the range of the identifier.
|
|
///
|
|
/// Clients should place the cursor on this range when navigating to this target.
|
|
///
|
|
/// This range must be contained within [`Self::full_range`].
|
|
pub focus_range: Option<TextRange>,
|
|
pub name: SmolStr,
|
|
pub kind: Option<SymbolKind>,
|
|
pub container_name: Option<SmolStr>,
|
|
pub description: Option<String>,
|
|
pub docs: Option<Documentation>,
|
|
/// In addition to a `name` field, a `NavigationTarget` may also be aliased
|
|
/// In such cases we want a `NavigationTarget` to be accessible by its alias
|
|
pub alias: Option<SmolStr>,
|
|
}
|
|
|
|
impl fmt::Debug for NavigationTarget {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let mut f = f.debug_struct("NavigationTarget");
|
|
macro_rules! opt {
|
|
($($name:ident)*) => {$(
|
|
if let Some(it) = &self.$name {
|
|
f.field(stringify!($name), it);
|
|
}
|
|
)*}
|
|
}
|
|
f.field("file_id", &self.file_id).field("full_range", &self.full_range);
|
|
opt!(focus_range);
|
|
f.field("name", &self.name);
|
|
opt!(kind container_name description docs);
|
|
f.finish()
|
|
}
|
|
}
|
|
|
|
pub(crate) trait ToNav {
|
|
fn to_nav(&self, db: &RootDatabase) -> UpmappingResult<NavigationTarget>;
|
|
}
|
|
|
|
pub trait TryToNav {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>>;
|
|
}
|
|
|
|
impl<T: TryToNav, U: TryToNav> TryToNav for Either<T, U> {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
match self {
|
|
Either::Left(it) => it.try_to_nav(db),
|
|
Either::Right(it) => it.try_to_nav(db),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl NavigationTarget {
|
|
pub fn focus_or_full_range(&self) -> TextRange {
|
|
self.focus_range.unwrap_or(self.full_range)
|
|
}
|
|
|
|
pub(crate) fn from_module_to_decl(
|
|
db: &RootDatabase,
|
|
module: hir::Module,
|
|
) -> UpmappingResult<NavigationTarget> {
|
|
let name = module.name(db).map(|it| it.to_smol_str()).unwrap_or_default();
|
|
match module.declaration_source(db) {
|
|
Some(InFile { value, file_id }) => {
|
|
orig_range_with_focus(db, file_id, value.syntax(), value.name()).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| {
|
|
let mut res = NavigationTarget::from_syntax(
|
|
file_id,
|
|
name.clone(),
|
|
focus_range,
|
|
full_range,
|
|
SymbolKind::Module,
|
|
);
|
|
res.docs = module.docs(db);
|
|
res.description = Some(module.display(db).to_string());
|
|
res
|
|
},
|
|
)
|
|
}
|
|
_ => module.to_nav(db),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn debug_render(&self) -> String {
|
|
let mut buf = format!(
|
|
"{} {:?} {:?} {:?}",
|
|
self.name,
|
|
self.kind.unwrap(),
|
|
self.file_id,
|
|
self.full_range
|
|
);
|
|
if let Some(focus_range) = self.focus_range {
|
|
buf.push_str(&format!(" {focus_range:?}"))
|
|
}
|
|
if let Some(container_name) = &self.container_name {
|
|
buf.push_str(&format!(" {container_name}"))
|
|
}
|
|
buf
|
|
}
|
|
|
|
/// Allows `NavigationTarget` to be created from a `NameOwner`
|
|
pub(crate) fn from_named(
|
|
db: &RootDatabase,
|
|
InFile { file_id, value }: InFile<&dyn ast::HasName>,
|
|
kind: SymbolKind,
|
|
) -> UpmappingResult<NavigationTarget> {
|
|
let name: SmolStr = value.name().map(|it| it.text().into()).unwrap_or_else(|| "_".into());
|
|
|
|
orig_range_with_focus(db, file_id, value.syntax(), value.name()).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| {
|
|
NavigationTarget::from_syntax(file_id, name.clone(), focus_range, full_range, kind)
|
|
},
|
|
)
|
|
}
|
|
|
|
fn from_syntax(
|
|
file_id: FileId,
|
|
name: SmolStr,
|
|
focus_range: Option<TextRange>,
|
|
full_range: TextRange,
|
|
kind: SymbolKind,
|
|
) -> NavigationTarget {
|
|
NavigationTarget {
|
|
file_id,
|
|
name,
|
|
kind: Some(kind),
|
|
full_range,
|
|
focus_range,
|
|
container_name: None,
|
|
description: None,
|
|
docs: None,
|
|
alias: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TryToNav for FileSymbol {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
let root = db.parse_or_expand(self.loc.hir_file_id);
|
|
self.loc.ptr.to_node(&root);
|
|
Some(
|
|
orig_range_with_focus(
|
|
db,
|
|
self.loc.hir_file_id,
|
|
&self.loc.ptr.to_node(&root),
|
|
Some(self.loc.name_ptr.to_node(&root)),
|
|
)
|
|
.map(|(FileRange { file_id, range: full_range }, focus_range)| {
|
|
NavigationTarget {
|
|
file_id,
|
|
name: self
|
|
.is_alias
|
|
.then(|| self.def.name(db))
|
|
.flatten()
|
|
.map_or_else(|| self.name.clone(), |it| it.to_smol_str()),
|
|
alias: self.is_alias.then(|| self.name.clone()),
|
|
kind: Some(hir::ModuleDefId::from(self.def).into()),
|
|
full_range,
|
|
focus_range,
|
|
container_name: self.container_name.clone(),
|
|
description: match self.def {
|
|
hir::ModuleDef::Module(it) => Some(it.display(db).to_string()),
|
|
hir::ModuleDef::Function(it) => Some(it.display(db).to_string()),
|
|
hir::ModuleDef::Adt(it) => Some(it.display(db).to_string()),
|
|
hir::ModuleDef::Variant(it) => Some(it.display(db).to_string()),
|
|
hir::ModuleDef::Const(it) => Some(it.display(db).to_string()),
|
|
hir::ModuleDef::Static(it) => Some(it.display(db).to_string()),
|
|
hir::ModuleDef::Trait(it) => Some(it.display(db).to_string()),
|
|
hir::ModuleDef::TraitAlias(it) => Some(it.display(db).to_string()),
|
|
hir::ModuleDef::TypeAlias(it) => Some(it.display(db).to_string()),
|
|
hir::ModuleDef::Macro(it) => Some(it.display(db).to_string()),
|
|
hir::ModuleDef::BuiltinType(_) => None,
|
|
},
|
|
docs: None,
|
|
}
|
|
}),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl TryToNav for Definition {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
match self {
|
|
Definition::Local(it) => Some(it.to_nav(db)),
|
|
Definition::Label(it) => Some(it.to_nav(db)),
|
|
Definition::Module(it) => Some(it.to_nav(db)),
|
|
Definition::Macro(it) => it.try_to_nav(db),
|
|
Definition::Field(it) => it.try_to_nav(db),
|
|
Definition::SelfType(it) => it.try_to_nav(db),
|
|
Definition::GenericParam(it) => it.try_to_nav(db),
|
|
Definition::Function(it) => it.try_to_nav(db),
|
|
Definition::Adt(it) => it.try_to_nav(db),
|
|
Definition::Variant(it) => it.try_to_nav(db),
|
|
Definition::Const(it) => it.try_to_nav(db),
|
|
Definition::Static(it) => it.try_to_nav(db),
|
|
Definition::Trait(it) => it.try_to_nav(db),
|
|
Definition::TraitAlias(it) => it.try_to_nav(db),
|
|
Definition::TypeAlias(it) => it.try_to_nav(db),
|
|
Definition::ExternCrateDecl(it) => Some(it.try_to_nav(db)?),
|
|
Definition::BuiltinType(_) | Definition::TupleField(_) => None,
|
|
Definition::ToolModule(_) => None,
|
|
Definition::BuiltinAttr(_) => None,
|
|
// FIXME: The focus range should be set to the helper declaration
|
|
Definition::DeriveHelper(it) => it.derive().try_to_nav(db),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::ModuleDef {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
match self {
|
|
hir::ModuleDef::Module(it) => Some(it.to_nav(db)),
|
|
hir::ModuleDef::Function(it) => it.try_to_nav(db),
|
|
hir::ModuleDef::Adt(it) => it.try_to_nav(db),
|
|
hir::ModuleDef::Variant(it) => it.try_to_nav(db),
|
|
hir::ModuleDef::Const(it) => it.try_to_nav(db),
|
|
hir::ModuleDef::Static(it) => it.try_to_nav(db),
|
|
hir::ModuleDef::Trait(it) => it.try_to_nav(db),
|
|
hir::ModuleDef::TraitAlias(it) => it.try_to_nav(db),
|
|
hir::ModuleDef::TypeAlias(it) => it.try_to_nav(db),
|
|
hir::ModuleDef::Macro(it) => it.try_to_nav(db),
|
|
hir::ModuleDef::BuiltinType(_) => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) trait ToNavFromAst: Sized {
|
|
const KIND: SymbolKind;
|
|
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
|
|
_ = db;
|
|
None
|
|
}
|
|
}
|
|
|
|
fn container_name(db: &RootDatabase, t: impl HasContainer) -> Option<SmolStr> {
|
|
match t.container(db) {
|
|
hir::ItemContainer::Trait(it) => Some(it.name(db).to_smol_str()),
|
|
// FIXME: Handle owners of blocks correctly here
|
|
hir::ItemContainer::Module(it) => it.name(db).map(|name| name.to_smol_str()),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
impl ToNavFromAst for hir::Function {
|
|
const KIND: SymbolKind = SymbolKind::Function;
|
|
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
|
|
container_name(db, self)
|
|
}
|
|
}
|
|
|
|
impl ToNavFromAst for hir::Const {
|
|
const KIND: SymbolKind = SymbolKind::Const;
|
|
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
|
|
container_name(db, self)
|
|
}
|
|
}
|
|
impl ToNavFromAst for hir::Static {
|
|
const KIND: SymbolKind = SymbolKind::Static;
|
|
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
|
|
container_name(db, self)
|
|
}
|
|
}
|
|
impl ToNavFromAst for hir::Struct {
|
|
const KIND: SymbolKind = SymbolKind::Struct;
|
|
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
|
|
container_name(db, self)
|
|
}
|
|
}
|
|
impl ToNavFromAst for hir::Enum {
|
|
const KIND: SymbolKind = SymbolKind::Enum;
|
|
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
|
|
container_name(db, self)
|
|
}
|
|
}
|
|
impl ToNavFromAst for hir::Variant {
|
|
const KIND: SymbolKind = SymbolKind::Variant;
|
|
}
|
|
impl ToNavFromAst for hir::Union {
|
|
const KIND: SymbolKind = SymbolKind::Union;
|
|
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
|
|
container_name(db, self)
|
|
}
|
|
}
|
|
impl ToNavFromAst for hir::TypeAlias {
|
|
const KIND: SymbolKind = SymbolKind::TypeAlias;
|
|
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
|
|
container_name(db, self)
|
|
}
|
|
}
|
|
impl ToNavFromAst for hir::Trait {
|
|
const KIND: SymbolKind = SymbolKind::Trait;
|
|
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
|
|
container_name(db, self)
|
|
}
|
|
}
|
|
impl ToNavFromAst for hir::TraitAlias {
|
|
const KIND: SymbolKind = SymbolKind::TraitAlias;
|
|
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
|
|
container_name(db, self)
|
|
}
|
|
}
|
|
|
|
impl<D> TryToNav for D
|
|
where
|
|
D: HasSource + ToNavFromAst + Copy + HasDocs + HirDisplay,
|
|
D::Ast: ast::HasName,
|
|
{
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
let src = self.source(db)?;
|
|
Some(
|
|
NavigationTarget::from_named(
|
|
db,
|
|
src.as_ref().map(|it| it as &dyn ast::HasName),
|
|
D::KIND,
|
|
)
|
|
.map(|mut res| {
|
|
res.docs = self.docs(db);
|
|
res.description = Some(self.display(db).to_string());
|
|
res.container_name = self.container_name(db);
|
|
res
|
|
}),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl ToNav for hir::Module {
|
|
fn to_nav(&self, db: &RootDatabase) -> UpmappingResult<NavigationTarget> {
|
|
let InFile { file_id, value } = self.definition_source(db);
|
|
|
|
let name = self.name(db).map(|it| it.to_smol_str()).unwrap_or_default();
|
|
let (syntax, focus) = match &value {
|
|
ModuleSource::SourceFile(node) => (node.syntax(), None),
|
|
ModuleSource::Module(node) => (node.syntax(), node.name()),
|
|
ModuleSource::BlockExpr(node) => (node.syntax(), None),
|
|
};
|
|
|
|
orig_range_with_focus(db, file_id, syntax, focus).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| {
|
|
NavigationTarget::from_syntax(
|
|
file_id,
|
|
name.clone(),
|
|
focus_range,
|
|
full_range,
|
|
SymbolKind::Module,
|
|
)
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::Impl {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
let InFile { file_id, value } = self.source(db)?;
|
|
let derive_path = self.as_builtin_derive_path(db);
|
|
|
|
let (file_id, focus, syntax) = match &derive_path {
|
|
Some(attr) => (attr.file_id.into(), None, attr.value.syntax()),
|
|
None => (file_id, value.self_ty(), value.syntax()),
|
|
};
|
|
|
|
Some(orig_range_with_focus(db, file_id, syntax, focus).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| {
|
|
NavigationTarget::from_syntax(
|
|
file_id,
|
|
"impl".into(),
|
|
focus_range,
|
|
full_range,
|
|
SymbolKind::Impl,
|
|
)
|
|
},
|
|
))
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::ExternCrateDecl {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
let src = self.source(db)?;
|
|
let InFile { file_id, value } = src;
|
|
let focus = value
|
|
.rename()
|
|
.map_or_else(|| value.name_ref().map(Either::Left), |it| it.name().map(Either::Right));
|
|
|
|
Some(orig_range_with_focus(db, file_id, value.syntax(), focus).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| {
|
|
let mut res = NavigationTarget::from_syntax(
|
|
file_id,
|
|
self.alias_or_name(db).unwrap_or_else(|| self.name(db)).to_smol_str(),
|
|
focus_range,
|
|
full_range,
|
|
SymbolKind::Module,
|
|
);
|
|
|
|
res.docs = self.docs(db);
|
|
res.description = Some(self.display(db).to_string());
|
|
res.container_name = container_name(db, *self);
|
|
res
|
|
},
|
|
))
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::Field {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
let src = self.source(db)?;
|
|
|
|
let field_source = match &src.value {
|
|
FieldSource::Named(it) => {
|
|
NavigationTarget::from_named(db, src.with_value(it), SymbolKind::Field).map(
|
|
|mut res| {
|
|
res.docs = self.docs(db);
|
|
res.description = Some(self.display(db).to_string());
|
|
res
|
|
},
|
|
)
|
|
}
|
|
FieldSource::Pos(it) => orig_range(db, src.file_id, it.syntax()).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| {
|
|
NavigationTarget::from_syntax(
|
|
file_id,
|
|
format_smolstr!("{}", self.index()),
|
|
focus_range,
|
|
full_range,
|
|
SymbolKind::Field,
|
|
)
|
|
},
|
|
),
|
|
};
|
|
Some(field_source)
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::Macro {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
let src = self.source(db)?;
|
|
let name_owner: &dyn ast::HasName = match &src.value {
|
|
Either::Left(it) => it,
|
|
Either::Right(it) => it,
|
|
};
|
|
Some(
|
|
NavigationTarget::from_named(
|
|
db,
|
|
src.as_ref().with_value(name_owner),
|
|
self.kind(db).into(),
|
|
)
|
|
.map(|mut res| {
|
|
res.docs = self.docs(db);
|
|
res
|
|
}),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::Adt {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
match self {
|
|
hir::Adt::Struct(it) => it.try_to_nav(db),
|
|
hir::Adt::Union(it) => it.try_to_nav(db),
|
|
hir::Adt::Enum(it) => it.try_to_nav(db),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::AssocItem {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
match self {
|
|
AssocItem::Function(it) => it.try_to_nav(db),
|
|
AssocItem::Const(it) => it.try_to_nav(db),
|
|
AssocItem::TypeAlias(it) => it.try_to_nav(db),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::GenericParam {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
match self {
|
|
hir::GenericParam::TypeParam(it) => it.try_to_nav(db),
|
|
hir::GenericParam::ConstParam(it) => it.try_to_nav(db),
|
|
hir::GenericParam::LifetimeParam(it) => it.try_to_nav(db),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ToNav for LocalSource {
|
|
fn to_nav(&self, db: &RootDatabase) -> UpmappingResult<NavigationTarget> {
|
|
let InFile { file_id, value } = &self.source;
|
|
let file_id = *file_id;
|
|
let local = self.local;
|
|
let (node, name) = match &value {
|
|
Either::Left(bind_pat) => (bind_pat.syntax(), bind_pat.name()),
|
|
Either::Right(it) => (it.syntax(), it.name()),
|
|
};
|
|
|
|
orig_range_with_focus(db, file_id, node, name).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| {
|
|
let name = local.name(db).to_smol_str();
|
|
let kind = if local.is_self(db) {
|
|
SymbolKind::SelfParam
|
|
} else if local.is_param(db) {
|
|
SymbolKind::ValueParam
|
|
} else {
|
|
SymbolKind::Local
|
|
};
|
|
NavigationTarget {
|
|
file_id,
|
|
name,
|
|
alias: None,
|
|
kind: Some(kind),
|
|
full_range,
|
|
focus_range,
|
|
container_name: None,
|
|
description: None,
|
|
docs: None,
|
|
}
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
impl ToNav for hir::Local {
|
|
fn to_nav(&self, db: &RootDatabase) -> UpmappingResult<NavigationTarget> {
|
|
self.primary_source(db).to_nav(db)
|
|
}
|
|
}
|
|
|
|
impl ToNav for hir::Label {
|
|
fn to_nav(&self, db: &RootDatabase) -> UpmappingResult<NavigationTarget> {
|
|
let InFile { file_id, value } = self.source(db);
|
|
let name = self.name(db).to_smol_str();
|
|
|
|
orig_range_with_focus(db, file_id, value.syntax(), value.lifetime()).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| NavigationTarget {
|
|
file_id,
|
|
name: name.clone(),
|
|
alias: None,
|
|
kind: Some(SymbolKind::Label),
|
|
full_range,
|
|
focus_range,
|
|
container_name: None,
|
|
description: None,
|
|
docs: None,
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::TypeParam {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
let InFile { file_id, value } = self.merge().source(db)?;
|
|
let name = self.name(db).to_smol_str();
|
|
|
|
let value = match value {
|
|
Either::Left(ast::TypeOrConstParam::Type(x)) => Either::Left(x),
|
|
Either::Left(ast::TypeOrConstParam::Const(_)) => {
|
|
never!();
|
|
return None;
|
|
}
|
|
Either::Right(x) => Either::Right(x),
|
|
};
|
|
|
|
let syntax = match &value {
|
|
Either::Left(type_param) => type_param.syntax(),
|
|
Either::Right(trait_) => trait_.syntax(),
|
|
};
|
|
let focus = value.as_ref().either(|it| it.name(), |it| it.name());
|
|
|
|
Some(orig_range_with_focus(db, file_id, syntax, focus).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| NavigationTarget {
|
|
file_id,
|
|
name: name.clone(),
|
|
alias: None,
|
|
kind: Some(SymbolKind::TypeParam),
|
|
full_range,
|
|
focus_range,
|
|
container_name: None,
|
|
description: None,
|
|
docs: None,
|
|
},
|
|
))
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::TypeOrConstParam {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
self.split(db).try_to_nav(db)
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::LifetimeParam {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
let InFile { file_id, value } = self.source(db)?;
|
|
let name = self.name(db).to_smol_str();
|
|
|
|
Some(orig_range(db, file_id, value.syntax()).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| NavigationTarget {
|
|
file_id,
|
|
name: name.clone(),
|
|
alias: None,
|
|
kind: Some(SymbolKind::LifetimeParam),
|
|
full_range,
|
|
focus_range,
|
|
container_name: None,
|
|
description: None,
|
|
docs: None,
|
|
},
|
|
))
|
|
}
|
|
}
|
|
|
|
impl TryToNav for hir::ConstParam {
|
|
fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
|
|
let InFile { file_id, value } = self.merge().source(db)?;
|
|
let name = self.name(db).to_smol_str();
|
|
|
|
let value = match value {
|
|
Either::Left(ast::TypeOrConstParam::Const(x)) => x,
|
|
_ => {
|
|
never!();
|
|
return None;
|
|
}
|
|
};
|
|
|
|
Some(orig_range_with_focus(db, file_id, value.syntax(), value.name()).map(
|
|
|(FileRange { file_id, range: full_range }, focus_range)| NavigationTarget {
|
|
file_id,
|
|
name: name.clone(),
|
|
alias: None,
|
|
kind: Some(SymbolKind::ConstParam),
|
|
full_range,
|
|
focus_range,
|
|
container_name: None,
|
|
description: None,
|
|
docs: None,
|
|
},
|
|
))
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct UpmappingResult<T> {
|
|
/// The macro call site.
|
|
pub call_site: T,
|
|
/// The macro definition site, if relevant.
|
|
pub def_site: Option<T>,
|
|
}
|
|
|
|
impl<T> UpmappingResult<T> {
|
|
pub fn call_site(self) -> T {
|
|
self.call_site
|
|
}
|
|
|
|
pub fn collect<FI: FromIterator<T>>(self) -> FI {
|
|
FI::from_iter(self)
|
|
}
|
|
}
|
|
|
|
impl<T> IntoIterator for UpmappingResult<T> {
|
|
type Item = T;
|
|
|
|
type IntoIter = <ArrayVec<T, 2> as IntoIterator>::IntoIter;
|
|
|
|
fn into_iter(self) -> Self::IntoIter {
|
|
self.def_site
|
|
.into_iter()
|
|
.chain(Some(self.call_site))
|
|
.collect::<ArrayVec<_, 2>>()
|
|
.into_iter()
|
|
}
|
|
}
|
|
|
|
impl<T> UpmappingResult<T> {
|
|
fn map<U>(self, f: impl Fn(T) -> U) -> UpmappingResult<U> {
|
|
UpmappingResult { call_site: f(self.call_site), def_site: self.def_site.map(f) }
|
|
}
|
|
}
|
|
|
|
/// Returns the original range of the syntax node, and the range of the name mapped out of macro expansions
|
|
/// May return two results if the mapped node originates from a macro definition in which case the
|
|
/// second result is the creating macro call.
|
|
fn orig_range_with_focus(
|
|
db: &RootDatabase,
|
|
hir_file: HirFileId,
|
|
value: &SyntaxNode,
|
|
name: Option<impl AstNode>,
|
|
) -> UpmappingResult<(FileRange, Option<TextRange>)> {
|
|
let Some(name) = name else { return orig_range(db, hir_file, value) };
|
|
|
|
let call_kind =
|
|
|| db.lookup_intern_macro_call(hir_file.macro_file().unwrap().macro_call_id).kind;
|
|
|
|
let def_range = || {
|
|
db.lookup_intern_macro_call(hir_file.macro_file().unwrap().macro_call_id)
|
|
.def
|
|
.definition_range(db)
|
|
};
|
|
|
|
let value_range = InFile::new(hir_file, value).original_file_range_opt(db);
|
|
let ((call_site_range, call_site_focus), def_site) =
|
|
match InFile::new(hir_file, name.syntax()).original_file_range_opt(db) {
|
|
// call site name
|
|
Some((focus_range, ctxt)) if ctxt.is_root() => {
|
|
// Try to upmap the node as well, if it ends up in the def site, go back to the call site
|
|
(
|
|
(
|
|
match value_range {
|
|
// name is in the node in the macro input so we can return it
|
|
Some((range, ctxt))
|
|
if ctxt.is_root()
|
|
&& range.file_id == focus_range.file_id
|
|
&& range.range.contains_range(focus_range.range) =>
|
|
{
|
|
range
|
|
}
|
|
// name lies outside the node, so instead point to the macro call which
|
|
// *should* contain the name
|
|
_ => {
|
|
let kind = call_kind();
|
|
let range = kind.clone().original_call_range_with_body(db);
|
|
//If the focus range is in the attribute/derive body, we
|
|
// need to point the call site to the entire body, if not, fall back
|
|
// to the name range of the attribute/derive call
|
|
// FIXME: Do this differently, this is very inflexible the caller
|
|
// should choose this behavior
|
|
if range.file_id == focus_range.file_id
|
|
&& range.range.contains_range(focus_range.range)
|
|
{
|
|
range
|
|
} else {
|
|
kind.original_call_range(db)
|
|
}
|
|
}
|
|
},
|
|
Some(focus_range),
|
|
),
|
|
// no def site relevant
|
|
None,
|
|
)
|
|
}
|
|
|
|
// def site name
|
|
// FIXME: This can be de improved
|
|
Some((focus_range, _ctxt)) => {
|
|
match value_range {
|
|
// but overall node is in macro input
|
|
Some((range, ctxt)) if ctxt.is_root() => (
|
|
// node mapped up in call site, show the node
|
|
(range, None),
|
|
// def site, if the name is in the (possibly) upmapped def site range, show the
|
|
// def site
|
|
{
|
|
let (def_site, _) = def_range().original_node_file_range(db);
|
|
(def_site.file_id == focus_range.file_id
|
|
&& def_site.range.contains_range(focus_range.range))
|
|
.then_some((def_site, Some(focus_range)))
|
|
},
|
|
),
|
|
// node is in macro def, just show the focus
|
|
_ => (
|
|
// show the macro call
|
|
(call_kind().original_call_range(db), None),
|
|
Some((focus_range, Some(focus_range))),
|
|
),
|
|
}
|
|
}
|
|
// lost name? can't happen for single tokens
|
|
None => return orig_range(db, hir_file, value),
|
|
};
|
|
|
|
UpmappingResult {
|
|
call_site: (
|
|
call_site_range,
|
|
call_site_focus.and_then(|FileRange { file_id, range }| {
|
|
if call_site_range.file_id == file_id && call_site_range.range.contains_range(range)
|
|
{
|
|
Some(range)
|
|
} else {
|
|
None
|
|
}
|
|
}),
|
|
),
|
|
def_site: def_site.map(|(def_site_range, def_site_focus)| {
|
|
(
|
|
def_site_range,
|
|
def_site_focus.and_then(|FileRange { file_id, range }| {
|
|
if def_site_range.file_id == file_id
|
|
&& def_site_range.range.contains_range(range)
|
|
{
|
|
Some(range)
|
|
} else {
|
|
None
|
|
}
|
|
}),
|
|
)
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn orig_range(
|
|
db: &RootDatabase,
|
|
hir_file: HirFileId,
|
|
value: &SyntaxNode,
|
|
) -> UpmappingResult<(FileRange, Option<TextRange>)> {
|
|
UpmappingResult {
|
|
call_site: (InFile::new(hir_file, value).original_file_range(db), None),
|
|
def_site: None,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use expect_test::expect;
|
|
|
|
use crate::{fixture, Query};
|
|
|
|
#[test]
|
|
fn test_nav_for_symbol() {
|
|
let (analysis, _) = fixture::file(
|
|
r#"
|
|
enum FooInner { }
|
|
fn foo() { enum FooInner { } }
|
|
"#,
|
|
);
|
|
|
|
let navs = analysis.symbol_search(Query::new("FooInner".to_owned()), !0).unwrap();
|
|
expect![[r#"
|
|
[
|
|
NavigationTarget {
|
|
file_id: FileId(
|
|
0,
|
|
),
|
|
full_range: 0..17,
|
|
focus_range: 5..13,
|
|
name: "FooInner",
|
|
kind: Enum,
|
|
description: "enum FooInner",
|
|
},
|
|
NavigationTarget {
|
|
file_id: FileId(
|
|
0,
|
|
),
|
|
full_range: 29..46,
|
|
focus_range: 34..42,
|
|
name: "FooInner",
|
|
kind: Enum,
|
|
container_name: "foo",
|
|
description: "enum FooInner",
|
|
},
|
|
]
|
|
"#]]
|
|
.assert_debug_eq(&navs);
|
|
}
|
|
|
|
#[test]
|
|
fn test_world_symbols_are_case_sensitive() {
|
|
let (analysis, _) = fixture::file(
|
|
r#"
|
|
fn foo() {}
|
|
struct Foo;
|
|
"#,
|
|
);
|
|
|
|
let navs = analysis.symbol_search(Query::new("foo".to_owned()), !0).unwrap();
|
|
assert_eq!(navs.len(), 2)
|
|
}
|
|
}
|